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

Without annotations, the description discloses return format, credit cost, and relationship to insumer_verify. However, it does not explicitly state read-only nature or side effects, leaving minor 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?

Three sentences, each adding value: purpose, return details, and context (verification, cost). No wasted words. 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?

Explains return format despite no output schema, mentions credit cost and sibling relation. Lacks explicit guidance on wallet field mutual exclusivity, but covers essential aspects.

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 baseline is 3. The description adds no new parameter meaning beyond repeating that items are optional, which is already in 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 the tool checks discount eligibility in ACP format, returns specific objects (coupons, applied/rejected arrays, per-item allocations), and distinguishes itself from siblings like insumer_verify by specifying ACP wrapping.

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 ACP checkout flows and contrasts with insumer_verify. It mentions credit cost but does not explicitly state when not to use or list all alternatives.

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

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

With no annotations, the description details behavioral traits: returns ECDSA-signed boolean results with kid, never exposes balances, includes evaluatedCondition, conditionHash, blockNumber/blockTimestamp for RPC chains, XRPL specifics, trust line state, credit costs, and proof mode. This fully compensates for missing annotations.

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

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

The description is a single paragraph but is information-dense. Key information is front-loaded. Every sentence adds value, though a structured bullet list could improve readability. It is still concise for the complexity covered.

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?

No output schema is present, but the description thoroughly explains return values, including per-condition fields and chain-specific differences. It covers all mode variations (standard, proof, JWT format) and condition types. The description is complete given the tool's complexity.

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%, but the description adds critical context: e.g., for bitcoinWallet use chainId 'bitcoin' with contractAddress 'native', for XRPL trust lines use currency, for Farcaster type 'farcaster_id', and template names for EAS. It explains the JWT format parameter. This goes well 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 'Create on-chain verification (attestation)' and specifies the scope: verifying 1-10 conditions across 33 chains. It distinguishes from sibling tools like insumer_compliance_templates by referencing it for listing templates, and insumer_verify is a different operation. The verb 'verify' and resource 'attestation' are 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 explains when to use the tool (to create attestations) and provides guidance on modes, credits, and template usage. It explicitly advises using insumer_compliance_templates to list available templates, indicating a decision point. However, it does not contrast with other sibling tools like insumer_verify or explicitly state when not to use it.

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

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

With no annotations, description discloses key behaviors: batch speed advantage, independent ECDSA signatures, partial success (failed wallets get error entries), credit costs (3/6 credits per successful wallet), and the 'merkle' proof option. It could add more on rate limits or idempotency but is sufficiently transparent for a non-destructive batch 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?

Description is a single paragraph of 4 sentences, front-loading the main purpose, then efficiency, then profile details, then partial success and costs. Every sentence adds value with no wasted 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?

Given the tool's complexity (batch, multi-wallet, proof option, credits, partial success), the description covers these aspects well. It lacks explicit return format details, but since output schema is absent, the description could be considered complete enough. The partial success and credit details add sufficient context for an agent to decide.

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%, but description adds value beyond schema: shared block fetches, ECDSA-signed profiles with TRST-XXXXX IDs, partial success handling, and credit cost details. The proof parameter is well explained in both schema and description. Overall enriches parameter understanding.

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 generates wallet trust fact profiles for up to 10 wallets in a single request. It uses specific verbs and resource (generate, wallet trust fact profiles) and distinguishes from siblings like insumer_wallet_trust by emphasizing batch processing and speed improvement.

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?

Description explains when to use the tool: for batch profiling with shared block fetches (5-8x faster) and partial success. It implicitly discourages sequential calls. However, it does not explicitly state when not to use or list alternatives like the singular version, but does mention the proof option as an alternative use case.

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 discloses behavioral traits: pricing tiers, minimum amount, crypto types, chains, risk of unrecoverable funds, non-refundable nature, wallet registration, and updateWallet option.

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?

Description is information-dense and well-structured, starting with purpose then details. Slightly long but each sentence adds value. Could be slightly more concise.

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

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

Given 4 parameters, no output schema, and no annotations, the description covers all essential aspects: how to use, what happens, risks, and wallet management. It is complete enough for agent decision-making.

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 has 100% coverage, but description adds value beyond schema, e.g., clarifying that amount is not required for BTC, and explaining updateWallet behavior. This enhances parameter understanding.

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 buys verification credits with specific cryptocurrencies. It distinguishes from siblings like 'insumer_buy_key' and 'insumer_buy_merchant_credits' by specifying 'verification credits'.

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: when to buy credits with crypto, pricing, and wallet registration. It does not explicitly state when not to use or compare to alternatives, but the context is sufficient.

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, but description covers all behavioral traits: payment methods, wallet addresses, auto-detection, BTC conversion, one key per wallet, volume discounts, and non-refundable nature.

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?

Compact paragraph with all essential info, though slightly dense. No redundancy, but could be broken into bullets for clarity.

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

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

Comprehensive coverage of payment methods, wallets, discounts, and exceptions (non-refundable, one key per wallet). Sufficient for an agent to use 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 coverage is 100%, and description adds context: txHash as proof, chainId details, amount minimum and BTC exception, appName as key name.

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 'Buy' and resource 'new API key' with specific payment methods, and distinguishes from sibling 'insumer_buy_credits' for topping up.

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?

Explicitly states no auth required and 'Agent-friendly: no email needed.' Also provides alternative: 'One key per wallet — use insumer_buy_credits to top up.'

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?

Discloses non-refundable, owner-only nature, wallet registration behavior, auto-detection of tokens on EVM/Solana, BTC conversion with confirmation, and volume discounts. No annotations, so description fully covers behavioral traits.

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

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

Single paragraph packs many details efficiently. Could be restructured for readability (e.g., bullet points for discounts), but it's not overly verbose and all information is relevant.

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?

Covers key aspects: payment methods, wallet registration, volume discounts. However, lacks explanation of return values or post-purchase state (e.g., how credits are reflected) since no output schema.

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

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

Schema covers 100% of parameters with descriptions. Description adds context like volume discounts and wallet registration but doesn't significantly enhance parameter understanding beyond 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 it buys merchant verification credits with specific tokens (USDC, USDT, BTC) and includes volume discounts. It differentiates from siblings like 'insumer_buy_credits' by specifying 'merchant' and 'verification'.

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 clear context: owner-only, minimum amount, wallet registration on first purchase, and how to update wallet. However, doesn't explicitly say when not to use or compare to alternatives like 'insumer_buy_key'.

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 provides some behavioral traits: it checks on-chain balances, never returns raw amounts, and is free (no credit consumption). However, it does not disclose side effects, error handling, rate limits, or what happens if a wallet is not found. The transparency is moderate but not insufficient.

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 with key information front-loaded. Each sentence adds value: purpose, behavioral constraint, cost. No redundant or missing critical info. Could be slightly more structured but efficient overall.

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

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

For a tool with 4 parameters and no output schema, the description explains what the tool does and what it returns (tier and discount percentage per token), but lacks return format details, edge cases (e.g., no wallet provided), and examples. It is adequate but not fully complete.

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

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

Schema coverage is 100% and already describes each parameter (merchant ID, wallet addresses). The description adds minimal extra meaning beyond 'checks on-chain balances', but does not clarify which wallet(s) are expected or if multiple can be provided. It fails to guide parameter selection beyond the schema, 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?

Description clearly states it calculates discount for a wallet at a merchant by checking on-chain balances, returning tier and discount percentage per token. Distinguished from sibling tools (e.g., insumer_acp_discount, insumer_ucp_discount) by focusing on discount calculation and stating it never returns raw balance amounts.

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

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

No explicit guidance on when to use this tool versus alternative discount tools (acp, ucp). Lacks exclusions or prerequisites, such as requiring at least one wallet address. Implied usage is for checking discounts, but context of selection among siblings is missing.

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 full burden. It states the tool lists templates and requires no authentication or credits, which is transparent about its safe, read-only nature. No hidden behaviors are implied.

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 short sentences, each earning its place: purpose, examples, and usage guidance. No fluff.

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

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

For a simple listing tool with no parameters and no output schema, the description covers the essential: what it does, how results are used, and cost/authentication. Could mention return format but not critical.

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

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

The input schema has zero parameters with 100% description coverage, so the description need not explain parameters. The baseline of 4 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 lists compliance templates for EAS attestation verification, and provides specific examples of providers (Coinbase Verifications on Base, Gitcoin Passport on Optimism). It distinguishes itself from siblings by explaining that templates are used with insumer_attest conditions.

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 tells users to 'Use a template name in insumer_attest conditions instead of specifying raw EAS parameters,' which gives clear guidance on when to use this tool. It also notes 'No authentication or credits required,' but does not explicitly state when not to use it.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It adds constraints (max 4, owner only) but does not explain side effects like replacing existing collections, immediate effect, or error handling. Partial but 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 very concise (one sentence plus a phrase) and front-loads the main purpose. Every sentence is useful, though a slightly more structured format (e.g., listing restrictions) could improve readability.

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

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

Given no output schema and no annotations, the description covers the tool's core function and key constraints but omits details like whether the configuration is additive or replacements, and what the return value indicates. Adequate but not 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 'id' and 'nftCollections' have descriptions). The tool description adds no additional meaning beyond the schema, so a 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 configures NFT collections for discounts, specifying the maximum of 4 collections and owner-only restriction. This distinguishes it from sibling tools like insumer_configure_tokens or insumer_check_discount.

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 mentions 'Owner only' as a usage restriction, but does not explicitly state when to use this tool versus alternatives (e.g., when to use insumer_configure_tokens for token-based discounts). Usage context is implied but not detailed.

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. It discloses 'Owner only' and 'All fields optional', but lacks details on side effects (e.g., whether changes are instantly applied, destructive potential of changing discount mode), atomicity, or return behavior.

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

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

The description is concise with two sentences covering the core purpose and constraints. However, it could be slightly more structured (e.g., bullet points for clarity) without adding length.

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

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

For a tool with 4 parameters including a nested object, the description covers basic intent and ownership but omits return value or success/error indications. Given the absence of an output schema, more context on expected outcomes would be beneficial.

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 minimal value beyond listing parameter categories, which are already well-documented in 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 the action ('Update'), the resource ('merchant settings'), and the specific fields ('discount stacking mode, cap, and stablecoin payment configuration'). It effectively distinguishes from sibling tools like insumer_create_merchant or insumer_configure_nfts by specifying the scope of settings.

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 ownership restriction ('Owner only') and implies usage context for updating merchant settings. While it does not explicitly contrast with siblings, the domain is clear enough for an AI to differentiate.

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 provided, so description carries the burden. It discloses ownership requirement and token limit, but lacks details on side effects (overwrites or appends), validation behavior, or error handling.

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 constraints, no wasted 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?

Given the complex nested schema, the description covers the high-level purpose and key constraints. It lacks detail on return values or error conditions, but the schema is rich enough to compensate.

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 detailed descriptions. The description adds value by stating 'Max 8 tokens total' (a constraint not in schema) and 'Owner only' (authorization context).

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 (configure), the resource (merchant token discount tiers), and key constraints (max 8 tokens, owner only). It distinguishes itself from sibling tools like configure_nfts or configure_settings.

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 mentions 'Owner only' indicating who should use it, but doesn't provide explicit guidance on when to use this tool versus alternatives or when not to use it.

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

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

No annotations provided, so description carries the burden. It discloses that the server verifies the transaction receipt on-chain, but does not specify idempotency, destructive vs. read-only, or any additional behavioral traits like rate limits or authentication 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?

Two sentences, front-loaded with the core purpose, and no wasted 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?

No output schema exists, and the description does not indicate what the tool returns (e.g., success confirmation or error). For a tool with 4 required parameters, the return value is missing, making it less 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 baseline is 3. The description does not add extra meaning beyond what is in the schema; it only restates the purpose without detailing parameters.

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

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

The description clearly states the verb 'confirm' and the resource 'stablecoin payment for a discount code.' It distinguishes itself from the sibling tool 'insumer_verify' by specifying it is to be called after verification and confirms on-chain payment.

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?

Explicitly says 'After calling insumer_verify,' providing clear sequential context. Does not explicitly list alternatives or when not to use, but the prerequisite relationship 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 were provided, so the description carries full burden. It discloses key behavioral traits: creation grants free credits, ownership by API key, and a limit of 10 merchants. This adds significant transparency beyond the input schema.

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

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

The description is two short sentences, front-loaded with the core action. Every sentence adds value (create, credits, ownership, limit). No wasted 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?

There is no output schema, and the description does not explain the return value of the tool. For a creation action, expected output (e.g., the created merchant object) is missing. However, the description covers creation behavior adequately. Given the lack of output schema, the description is partially complete.

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

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

Schema description coverage is 100%, meaning each parameter already has a description in the schema. The tool description does not add additional meaning or constraints for parameters beyond what the schema 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 'Create a new merchant', which is a specific verb+resource. It distinguishes from sibling tools like insumer_get_merchant or insumer_list_merchants by focusing on creation and adding unique context (free credits, ownership, limit).

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 usage guidance: 'Receives 100 free verification credits', 'The API key that creates the merchant owns it', and 'Max 10 merchants per API key'. This tells the agent when to use (e.g., when creating a new merchant and having capacity) and implies when not to (if already at 10). No explicit alternative is given, but context from siblings is available.

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. The description indicates a read-like operation (check) but does not explicitly state if it is safe, free, or has any side effects. It lacks details on authentication or rate limits for the tool itself, leaving some behavioral uncertainty.

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

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

A single, front-loaded sentence that efficiently conveys the tool's purpose without any unnecessary words. Every part of the description contributes to understanding.

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 no parameters and no output schema, the description fully specifies what information the tool provides (balance, tier, rate limit). It 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 input schema has zero parameters, and the description adds meaning by explaining what the tool returns (balance, tier, rate limit). Per the baseline rule for 0 parameters, a score of 4 is justified.

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 verb 'Check' and specifies three concrete resources: verification credit balance, tier (free/pro/enterprise), and daily rate limit. It is distinct from sibling tools like insumer_buy_credits or insumer_attest.

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 the agent needs current credit information or tier status. It does not explicitly contrast with alternatives, but the context is clear and no misleading information is present.

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 description fully responsible. States it's a read operation but doesn't disclose any behavioral traits like idempotency, rate limits, or authentication 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?

Single, focused sentence with no unnecessary words. Efficient 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?

For a simple retrieval tool with one parameter and no output schema, description adequately lists profile components. Missing return format details but acceptable given 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?

Schema covers 100% of parameters with single 'id' described as 'Merchant ID'. Description adds no extra detail beyond schema, baseline 3 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?

Clearly states tool retrieves full public merchant profile and lists included items (token tiers, NFT collections, discount mode, verification status). Distinct from siblings which are other actions like buy, configure, verify.

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 on when to use this vs alternatives such as insumer_list_merchants or insumer_merchant_status. Only describes function without context for selection.

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

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

With no annotations provided, the description covers behavioral traits well, stating it is a read operation and requires no authentication. It does not mention rate limits or response format, but for a simple get, this is sufficient.

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 short, front-loaded sentences with no extraneous information. Every sentence adds value: purpose, usage guidance, and authentication requirement.

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 (no parameters, no output schema), the description fully explains its purpose, usage, and a key behavioral note (no auth). It is complete for an agent to decide when 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?

The tool has zero parameters, so schema coverage is effectively 100%. The description does not need to add parameter details, and the baseline score of 4 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 tool retrieves the JWKS containing the ECDSA P-256 public signing key, distinguishing it from other sibling tools like insumer_attest or insumer_verify, which focus on different operations.

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

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

The description explicitly says to use this tool for verifying attestation signatures without hardcoding the key, and explains the role of the 'kid' field. It provides good usage context but does not explicitly mention when not to use it.

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

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

No annotations are provided, so the description carries the burden. It implies read-only by saying 'Browse' but does not explicitly state it is a safe read operation. It also lacks details on authentication, rate limits, or pagination behavior beyond parameters.

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, no wasted words. Purpose is front-loaded in the first sentence, followed by filters and output. Highly efficient.

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

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

Despite lacking annotations and output schema, the description covers the core action, filters, and return fields. It omits pagination behavior but the schema handles that. Reasonably complete for a list 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?

All parameters have descriptions in the schema (100% coverage), so baseline is 3. The description restates filtering but adds no extra meaning beyond the schema. The mention of return fields is helpful but not parameter-related.

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 ('Browse'), resource ('merchants in the public directory'), and what is returned. It distinguishes from siblings like 'insumer_get_merchant' (single) and 'insumer_create_merchant' (write).

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 listing merchants but does not explicitly contrast with other tools or provide when-to-use guidance. No mention of 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 carries the full burden. It states the tool lists all registered tokens and NFT collections, implying a read-only operation, but does not disclose details like permissions, pagination, or response format. This is adequate for a simple listing tool but lacks depth.

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 immediately conveys the core function and filtering options. No filler words, highly 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?

Given the tool's simplicity, the description provides enough information: it lists all registered tokens/NFTs and explains available filters. It lacks details on output structure but is sufficient for a basic listing tool with no output schema.

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

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

Schema description coverage is 100%, with each parameter having a clear description (e.g., 'Filter by chain ID'). The tool description merely reiterates the filters without adding new semantic meaning beyond the schema, so it meets the baseline for high 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-resource pair: 'List all registered tokens and NFT collections'. It clearly distinguishes from sibling tools like configure_tokens or configure_nfts, which are for configuration, not listing.

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 explains filtering options ('Filter by chain, symbol, or asset type'), giving context on how to narrow results. It does not explicitly contrast with alternatives, but the purpose is straightforward and does not require extensive 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 carries full burden. It notes 'private' and 'Owner only', implying authentication and restricted access, but lacks details on error behavior, rate limits, or what happens if the caller is not the owner.

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 front-loads the purpose and lists details. Every word adds value, with no redundancy.

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

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

Given no output schema, the description partially explains return contents by listing categories, but lacks structure details. Simple tool with one param, but missing completeness on error scenarios and output 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?

Schema coverage is 100% for the single parameter, so baseline is 3. The description does not add meaning to the 'id' parameter beyond the schema's 'Merchant ID'.

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 'Get' and the resource 'full private merchant details', listing specific categories. However, it does not distinguish from sibling tool 'insumer_get_merchant', which likely has a similar 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?

No guidance is provided on when to use this tool versus alternatives like 'insumer_get_merchant' or 'insumer_list_merchants'. The only hint is 'Owner only', which implies access restriction but not usage 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?

No annotations exist, so the description must fully disclose behavior. It mentions both publish and refresh modes and owner-only restriction, but lacks details on side effects (e.g., overwriting, idempotency) or what happens if called repeatedly. Adequate but 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?

Two sentences packed with key information: action, resource, update guidance, and access control. No wasted words, front-loaded purpose, and efficient structure.

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 tool with no output schema, the description provides sufficient context: what it does, when to call, and who can use it. Minor gap in not describing the return format, but not critical given low complexity.

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% coverage (one parameter described as 'Merchant ID'). The description does not add any additional meaning or usage hints beyond the schema, 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 uses a specific verb ('Publish') and resource ('merchant's listing in the public directory'), clearly distinguishing it from sibling tools like 'insumer_configure_settings' or 'insumer_get_merchant'. It also covers the refresh aspect, 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?

Provides explicit guidance to call again after updating tokens or settings, which is a valuable usage recommendation. It also notes 'Owner only', indicating authorization context, but does not compare to alternatives or state when not to use it.

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

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

No annotations are provided, so the description carries the burden. It reveals that the tool returns 'the token and three verification methods,' and that 'Verified merchants get a trust badge.' It also notes the permission requirement ('Owner only'). These add behavioral context beyond the schema.

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

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

The description is concise at 4 sentences, each adding value: purpose, return details, next step, benefit, and permission. No wasted words, well 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 description covers return values, next steps, and usage context. Even without an output schema, it provides enough information for an agent to understand and use the tool correctly. It also mentions the benefit (trust badge) and permission, making it contextually 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 baseline is 3. The description does not add additional meaning to parameters beyond the schema. It mentions 'domain' and 'merchant' implicitly but no extra details.

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

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

The description clearly states the tool's purpose: 'Request a domain verification token for a merchant.' It specifies the resource (domain verification token) and action (request). It also distinguishes from the sibling tool 'insumer_verify_domain' by explaining this is the first step before verification.

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: 'After placing the token, call insumer_verify_domain to complete verification.' This tells the agent when to use the sibling tool. It also mentions 'Owner only,' indicating who can use it. However, it lacks explicit when-not-to-use or alternative scenarios.

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 the key format (insr_live_...), included credits (10 verification, 100 calls/day), and usage limits. No contradictions with annotations.

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

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

Four sentences, each with a distinct purpose: generation, no credit card, what to do with the key, and limits. No redundant or wasted 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?

Given the tool's simplicity, the description covers all needed information: what it does, input parameters, output format, post-usage instructions, and rate limits. No output schema, but return value is adequately described.

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 basic descriptions. The overall description adds context about default appName ('MCP Agent') and confirms email is required, but does not add significant new meaning beyond 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 'Generate a free InsumerAPI key instantly', identifying the specific resource (API key) and action (generate). This sets it apart from sibling tools that deal with discounts, attestation, buying credits, etc.

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 context: no credit card required, one free key per email, 3 per IP per day, and instructions to add the key to MCP config and restart. It doesn't explicitly state when not to use it, but the purpose is clear enough to distinguish from alternatives.

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

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

With no annotations, the description covers key behaviors: read-only check, credit consumption, and return format. However, it lacks details on authentication requirements, idempotency, or potential side effects, leaving gaps that annotations would normally fill.

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, front-loaded with the purpose, and contains no redundant information. Every sentence serves a clear function, making it highly efficient.

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

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

Given the complexity of multi-chain wallet parameters and UCP format, the description provides essential context about output fields and credit consumption. It lacks examples or error handling but is sufficient for a well-documented schema.

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

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

Schema coverage is 100%, so the description adds limited value beyond the schema. It mentions return fields (title, extension field, applied array) but does not elaborate on parameters. The baseline of 3 is appropriate as 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 checks token-holder discount eligibility in UCP format, specifies return fields, and distinguishes it from insumer_verify by noting the same on-chain verification wrapped in UCP format. This provides a specific verb+resource with differentiation.

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 usage for UCP checkout flows and notes a credit cost, giving clear context for when to use it. While it does not explicitly exclude alternatives, the reference to UCP format and the sibling tools imply a specific use case, making guidance adequate.

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 provided, so description carries full burden. It clearly states 'No authentication required, no credits consumed. Does not expose wallet or token data.' Also explains return value (valid/invalid status with reason).

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 short sentences, each earning its place: purpose, context, and behavioral traits. No redundant or vague wording.

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

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

For a simple validation tool with no output schema, the description explains return value, authentication requirements, side effects (none), and data exposure. Completely covers what an agent needs 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?

Only one parameter 'code' with schema description covering 100%. Description adds the 'INSR-XXXXX' context which matches the schema pattern, but does not add significant new semantics beyond what schema already provides. Baseline 3 due to high 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?

Description clearly states the specific verb 'Validate' and resource 'INSR-XXXXX discount code'. It specifies the context (merchant backends during ACP/UCP checkout) and distinguishes from sibling tools like insumer_check_discount by focusing on a specific code format.

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?

Explicitly states when to use ('For merchant backends during ACP/UCP checkout to confirm code validity'). While it doesn't explicitly exclude other scenarios, the context is clear and alternatives are implied by sibling tool names.

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 full burden. It discloses the side effects (consumes 1 merchant credit, auto-creates coupon if Stripe Connect), the return values (tier and discount percentage, never raw balances), and that it is a write operation ('Create'). However, it does not mention authorization requirements 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 three concise sentences that front-load the core action (create code with format and expiry), then return values, then side effects. No redundant or unnecessary information.

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

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

While the description covers the code format, expiry, return values, and side effects, it lacks explanation of why three wallet address options exist, and does not mention what happens if no wallet is provided. With no output schema, the description partially compensates by stating return values, but incomplete on parameter details.

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 baseline is 3. The description does not add significant meaning beyond the schema's parameter descriptions; it only emphasizes that the code is for a wallet at a merchant, but does not clarify the relationship between the three wallet address fields (wallet, solanaWallet, xrplWallet) or their optionality.

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 'Create signed discount code' with format 'INSR-XXXXX' and 30-min expiry, and distinguishes from sibling tools like insumer_check_discount and insumer_validate_code which are for checking or validating codes.

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 mentions that it consumes 1 merchant credit and auto-creates coupons for Stripe Connect merchants, but does not provide explicit when-to-use or when-not-to-use guidance relative to siblings like insumer_check_discount or insumer_validate_code.

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?

Discloses that the server checks all three methods automatically, rate limited to 5 attempts per hour, and owner only. No annotations provided, so description carries full burden and does so well.

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, no redundant information. Front-loaded with 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?

Covers prerequisite, methods, rate limit, and ownership. Missing explanation of return values, but no output schema exists. Slightly incomplete for expected outcome.

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 parameter 'id' described as 'Merchant ID'. Description adds no further parameter semantics beyond schema, 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?

Clearly states the tool's purpose: verifying domain ownership for a merchant. Distinguishes from sibling by referencing the prerequisite step insumer_request_domain_verification.

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?

Explicitly says when to use (after placing verification token) and how token can be placed (DNS, meta tag, file upload). Includes rate limit and owner-only restriction but does not mention when not to use or alternative 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 carries full burden. It discloses that the tool returns 'per-dimension pass/fail counts and overall summary,' emphasizes 'No score, no opinion — just cryptographically verifiable evidence,' and mentions cost (3 or 6 credits). It does not explicitly state it is read-only but implies it via 'no opinion' and the nature of trust profiles. The absence of destructive hint is not misleading. Overall, it provides strong behavioral context beyond the schema.

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

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

The description is a single, well-organized paragraph. The first sentence states the main function. Subsequent sentences systematically enumerate checks, return values, and cost. Every sentence adds unique information with no redundancy. It is 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 tool has moderate complexity (5 parameters, optional multi-chain wallets). The description covers the overall process, supported assets, and return summary. Without an output schema, it provides a high-level description of what is returned ('per-dimension pass/fail counts and overall summary'). However, it lacks exact output format details (e.g., JSON structure, field names). Given the absence of output schema, the description is nearly complete.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by explaining that optional wallet parameters add specific checks (e.g., Solana adds USDC on Solana). It also clarifies the 'proof' parameter's effect (merkle proof costs 6 credits). This semantic enrichment 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 starts with a clear verb ('Generate') and specific resource ('wallet trust fact profile'). It enumerates the exact checks (36 base checks across stablecoins, governance, NFTs, staking) and distinguishes itself from siblings like insumer_batch_wallet_trust by implying a single-wallet operation. The purpose is highly specific and differentiated.

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

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

The description states it is 'Designed for AI agent-to-agent trust decisions,' providing context for use. However, it does not explicitly compare against sibling tools like insumer_batch_wallet_trust, nor does it specify when not to use it or list alternatives. The usage is implied but lacks exclusion guidance.

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