PikaSim

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

Annotations already indicate destructiveHint=true and readOnlyHint=false. The description adds valuable context: refund to wallet, the unused condition, and the API key requirement. No contradiction with annotations.

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

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

Two sentences, front-loaded with the main action and refund effect, then the condition and auth requirement. 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 single-param destructive tool with good annotations, the description covers purpose, preconditions, and auth. It omits return format or error behavior, but the lack of an output schema and the simple nature make this acceptable.

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 only parameter 'iccid' has a 100% schema description ('ICCID of the eSIM to cancel'). The tool description does not add extra parameter-level detail, so score is at the baseline of 3.

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' with the resource 'eSIM', and states the refund to wallet balance. It also limits to 'unused' eSIMs, distinguishing it from sibling cancel tools for SMS rentals/verifications.

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 a precondition ('Only works if the eSIM has not been installed or activated') and a requirement ('Requires an agent-wallet API key'). This gives clear context, though it does not name alternatives explicitly.

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

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

The annotations already mark it as destructive/openWorld/idempotent, but the description adds crucial context: the 2-hour window, the no-message requirement, the refund behavior, the clear-reason return on failure, and the connected-wallet prerequisite. This significantly exceeds the baseline.

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 earns its place: action, conditions, rationale, use case, parameter origin, and prerequisite. It front-loads the action and keeps a logical flow.

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 moderate complexity (conditional refund, time window) and no output schema, the description covers all critical aspects: success behavior, failure behavior, prerequisites, and source of the ID. The agent has enough to select and 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?

The input schema already describes receiptId fully as 'The rental receipt ID from rent_sms_number or list_sms_orders' with 100% coverage. The description repeats this same origin without adding any new meaning, so it merits the baseline 3.

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 a specific verb+resource ('Cancel a long-term SMS rental') and states the refund effect, clearly distinguishing it from sibling tools like cancel_sms_verification and cancel_esim. It also identifies the receiptId origin, making the tool's 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 conditions for when cancellation works (within 2 hours, no messages received) and explicitly says it returns a clear reason and refunds nothing if the window has passed or a code arrived. It also gives a concrete use case ('genuine change of mind or wrong purchase'). However, it lacks an explicit reference to an alternative cancellation tool for other resource types, so a 4 rather than 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?

Adds context beyond annotations: immediate refund to wallet, refusal if already delivered, and the wallet requirement. Annotations indicate readOnly=false and destructiveHint=false, and the description aligns with this (mutation but not destructive in the sense of data loss). No contradiction, but it could mention error handling or side effects of cancellation.

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-load the primary action and refund, followed by a conditional exception and prerequisite. All information is relevant with no redundancy or 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 one-parameter tool with annotations, the description covers the core behavior, refund, failure condition, alternative, and prerequisite. Missing only explicit return value information, but given no output schema and low complexity, this is acceptable.

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 parameter description already states 'Order ID of the waiting quick SMS order'. The tool description does not add additional semantic meaning beyond what the schema provides, hence baseline score.

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 cancels a quick SMS order and refunds it, distinguishing it from other cancellation tools like cancel_sms_rental and from the read-only check_sms_verification. The verb 'Cancel' is specific and the resource is well-defined.

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

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

Provides explicit usage conditions: 'still waiting for a code' indicates when to use, and 'Refused if the SMS was already delivered' gives a clear exclusion with an alternative tool named ('check_sms_verification instead'). Also mentions the prerequisite of a connected agent wallet.

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

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

Beyond the readOnlyHint annotation, the description adds that it 'makes no changes', requires a connected agent wallet (OAuth or ak_live_ key), and explains that if no wallet is connected, the response guides the user on connecting one. This discloses auth requirements and error 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: three sentences with the primary purpose front-loaded, followed by usage guidance, prerequisite, and error behavior. No redundant or irrelevant 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 a zero-parameter, read-only balance check with no output schema, the description covers the return value, prerequisites, when to use, and error handling. It is fully sufficient for an agent to invoke and interpret results.

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?

This tool has zero parameters, so the description need not explain parameter details. The baseline of 4 applies, and no additional parameter context is necessary or provided.

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

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

The description specifically states the tool 'Returns the prepaid spending balance of the connected PikaSim agent wallet, in USD', using a clear verb and resource. It differentiates from sibling tools by focusing on balance retrieval and explicitly naming related purchase tools.

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

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

Provides explicit usage guidance: 'Call this before purchase_esim or purchase_phone_plan to confirm sufficient funds, or any time you need the current balance.' Also notes a prerequisite (connected wallet) and what happens if unmet.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds behavioral context by disclosing the two-bucket response structure, including what counts as a PHONE-NUMBER eSIM (real carrier number, voice + SMS), which is a meaningful distinction beyond the schema. It does not contradict 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 exactly two sentences: the first states the primary action, the second details the return structure. Every phrase earns its place, and the use of capitalized bucket names improves readability without wordiness. It's front-loaded and efficient.

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

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

For a single-parameter read-only tool with no output schema, the description sufficiently covers the invocation and expected response: it names the two buckets and their fields. It could add details such as currency or representation of price ranges, but the provided information is enough to understand and apply the result.

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 fully describes the country parameter with an ISO code and examples, so the description need not add parameter details. The description mentions 'a country' but adds no semantics beyond the schema's 100% coverage. 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 ('Check') and resource ('PikaSim plans cover a country'), and clearly differentiates from siblings by specifying the two return buckets (DATA eSIMs and PHONE-NUMBER eSIMs) with their respective contents. This makes the tool's purpose unambiguous and distinguishes it from general search or pricing tools.

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

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

The description implicitly conveys when to use the tool: whenever an agent needs to know which PikaSim plans cover a specific country and wants both data and phone-number options. However, it does not explicitly mention alternatives or conditions where another sibling tool should be preferred, 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?

Beyond the annotations (readOnlyHint=true), the description adds critical behavioral details: 'Read-only', the polling cadence, the auto-refund within 20 minutes, and the wallet requirement. It also clarifies the expected output ('relay the code (and full message) to the user'), providing rich context beyond the annotations.

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

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

The description is four sentences, each serving a distinct purpose: what it does, when/how often to call, timeout behavior, and prerequisites. It is front-loaded with the core purpose and contains no fluff or repetition.

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

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

For a simple one-parameter tool with no output schema and existing annotations, the description covers the full context: purpose, operation, polling frequency, failure/timeout behavior, required precondition (wallet), and how to use the result. It leaves no critical gaps.

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

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

Schema coverage is 100% for the single parameter orderId, with the schema description already stating it's 'The Order ID returned by order_sms_verification'. The tool description references the same relationship in its usage guidance but does not add syntax or format details beyond what the schema already provides, so it meets the baseline but adds no 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 clearly states the tool's purpose: 'Poll a quick SMS order for the incoming verification code.' It uses a specific verb ('poll') and identifies the resource ('quick SMS order'). It also explains the workflow after polling, distinguishing it from sibling tools like get_sms_rental_messages by focusing on verification codes and the order lifecycle.

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 context: 'Call every 15-30 seconds after order_sms_verification until status is "received"'. It also mentions the auto-refund timeout and the need for a connected agent wallet. However, it does not explicitly contrast with alternative tools (e.g., get_sms_rental_messages), so it lacks direct alternative exclusion.

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

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

The description goes well beyond the minimal annotations (readOnlyHint=false, idempotentHint=false). It discloses that the tool does not move funds itself, payments happen externally, balance updates upon confirmation, fees for card payments, wallet properties (non-expiring, not redeemable), and authentication requirements. No contradiction with annotations.

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

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

The description is relatively long but every sentence carries substantive information (payment methods, autonomous agent usage, fees, wallet properties). It is well-structured and front-loaded, but could be slightly more concise; still efficient for the complexity.

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

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

For a financial tool with no output schema, the description comprehensively covers prerequisites (connected agent wallet, OAuth or ak_live_ key), payment instructions, fees, deposit minimum, and what happens after payment. It also distinguishes from sibling tools clearly. No significant 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?

The input schema provides 100% coverage for the sole parameter (amount), including type, minimum, and an example. The description repeats 'Minimum deposit is $1' but adds no new parameter semantics beyond what the schema already states. Therefore, the description adds minimal value over 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's action ('Creates a payment invoice to add funds') and resource (PikaSim Wallet). It distinguishes itself from siblings like check_balance and create_wallet by describing the deposit-specific function and return value (payment page link and per-coin crypto details).

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 'Use when check_balance is too low to purchase', giving a direct usage condition. It also describes two usage scenarios (human payment via card/crypto and autonomous agent paying crypto), further clarifying when to invoke 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?

Adds meaningful context beyond annotations: discloses that creating the wallet accepts ToS on the user's behalf, returns a spend-only credit, and requires no KYC/email. Annotations already indicate mutation, but the description enriches with legal and operational details that influence agent 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 front-loaded with the core purpose and efficiently packs necessary caveats (no human/KYC, what it returns, when to use, ToS). Slightly long, but every sentence adds distinct value without redundancy.

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

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

With no output schema, the description fully covers the return value (wallet code, API key, welcome credit), how to authenticate with the key, and what purchases can follow (eSIM, phone number, SMS). It is complete for a create-wallet 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?

Though the schema already describes acceptTos clearly, the description adds the critical behavioral implication: passing true means accepting ToS on the user's behalf. This goes beyond the schema's 'Must be true' and explains why the parameter exists, aiding correct invocation.

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

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

The description states a specific verb and resource: 'Create a NEW PikaSim agent wallet for autonomous purchasing.' It clearly distinguishes from siblings by noting when not to use it (if user already has a wallet, reconnect instead) and lists concrete outputs (wallet code, API key, credit).

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?

Explicit usage guidance is provided: 'Use this when the user has NO wallet yet' and 'If the user ALREADY has a wallet, do NOT create a new one — reconnect the existing wallet instead.' This directly tells the agent when to use this tool vs. 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?

Annotations mark destructiveHint=true and readOnlyHint=false; description adds specifics: it spends wallet balance, checks price first, reports charged amount, and days are added to current expiry. This goes beyond annotation hints and gives actionable context.

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?

One tight paragraph, front-loaded with the main purpose. Each sentence contributes critical info: action, cost behavior, time constraint, prerequisite. No filler.

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

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

For a 2-param action with no output schema, the description is sufficient. It covers behavior, impact on wallet, prerequisites, and failure warning (expired rentals). Return value not needed as 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 already covers both params with descriptions (100% coverage). Description adds context that days are added on top of current expiry and must match duration tiers. Reinforces schema without adding new syntax, so slightly better than 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?

Specific verb+resource: 'Extend a long-term SMS rental' clearly indicates the action and target. Distinguished from siblings by emphasizing keeping the same number and adding days, unlike cancel or list 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?

Explicitly states when to use: 'Extend BEFORE expiry; an expired rental usually cannot be recovered.' Also provides prerequisites: 'Requires a connected agent wallet.' Does not name alternatives but clearly implies this is for extension only, not cancellation or new rental.

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

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

Beyond the readOnlyHint annotation, the description lists the exact data points returned (coverage, data, voice/SMS allowance, duration, price, networks, URL), which is valuable since there is no output schema. The redundant 'Read-only' statement adds little, but the field enumeration gives transparency into the tool's 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 first sentence is dense and informative, front-loading the core purpose and return fields. The second sentence 'Read-only.' is redundant with the annotation, making it slightly wasteful, but overall the description is compact.

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 read-only tool, the description adequately covers return values and usage context, especially since there is no output schema. It does not mention error behavior (e.g., invalid id), but that is a minor gap for a fetch-by-id 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 provides a clear description for the id parameter as 'The plan id returned by the search tool (the packageCode)'. The description's phrase 'by the id returned from search' adds no new information, so the semantic value is 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 fetches full details for one PikaSim eSIM plan using the id from search, and enumerates the specific fields returned. However, it does not explicitly distinguish itself from the sibling tool get_package_details, which may serve 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?

The description provides clear context: use this after search to get comprehensive plan details by the returned id. It does not explicitly state when not to use it or mention alternative tools, but the use case is well implied.

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

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

The readOnlyHint annotation covers the read-only nature, and the description adds that the status is live, requires a connected agent wallet (OAuth or ak_live_ key), and applies only to eSIMs the user owns. This goes beyond the annotation without contradicting 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?

The description is five short sentences, each providing a distinct piece of value: what it returns, read-only nature, when to use, where to get the ICCID, and auth requirements. No filler or redundancy.

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

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

With no output schema, the description summarizes return values (live status, data used/remaining, expiration date), identifies the lookup key, and covers prerequisites like wallet connection. This is complete for a simple read-only lookup 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 already fully documents the iccid parameter with its source. The description reinforces this by explaining the ICCID is returned by purchase_esim, purchase_phone_plan, or list_orders, adding useful context 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 the tool returns live status, remaining/used data, and expiration date for a single eSIM identified by ICCID. This specific verb+resource combination distinguishes it from list_esims (which lists all eSIMs) and purchase_esim.

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 says to use after a purchase or when a user asks how much data is left or whether an eSIM is active. It does not name alternatives or exclusions, but the usage context is clear and actionable.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is known. The description adds the types of details returned and the source of packageCode, but does not disclose error behavior, rate limits, or other operational traits. It does not contradict annotations.

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

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

Two sentences, front-loaded with the tool's purpose and key output fields, no filler or redundancy.

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

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

For a simple single-parameter detail tool with no output schema, the description sufficiently lists the returned aspects and the input source. It could explicitly mention handling of invalid codes or differentiate from pricing tools, but overall it is complete enough 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%, with the packageCode parameter already well-documented with examples. The description adds slight context about the bracket format from search tools, but this is marginal over the schema, so a baseline 3 is appropriate.

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

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

The description clearly states the tool's function with a specific verb ('Get') and resource ('full details for a specific plan'), explicitly listing coverage, data, voice/SMS allowance, duration, price, networks, and purchase URL. It also distinguishes itself from sibling search tools by noting it accepts the packageCode shown in [brackets] by those search tools.

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

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

It implies usage after obtaining a packageCode from search tools, giving clear context for when to use this tool. However, it does not explicitly name alternatives or state when not to use it, stopping short of a 5.

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

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

Annotations already indicate readOnlyHint=true and openWorldHint=true, so the description's job is to add context. It adds the return values (USD price and voice/SMS/data allowance) and clarifies the input source, which is useful. 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?

Two sentences, front-loaded with the main purpose, and no wasted words. Every sentence contributes meaning.

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

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

Given the low complexity (2 params, no output schema), the description covers the essential aspects: what the tool returns, what input it needs, and where that input comes from. It could mention edge cases or error conditions, but for this simple read operation, 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?

Schema description coverage is 100%, so the schema already explains both parameters. The description adds minimal extra meaning (pointing to search_phone_plans as source), but the schema already provides examples and the currency limitation. This 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 a specific action ('Get the USD price and voice/SMS/data allowance') for a specific resource ('PHONE-NUMBER eSIM'), and distinguishes from siblings by referencing the source packageCode from search_phone_plans. This is a specific verb+resource+scope, making it easy to differentiate from other pricing tools.

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

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

The description provides clear usage context: it is used after search_phone_plans to retrieve pricing for a specific packageCode. It does not explicitly list exclusions or alternative tools, but the flow is implied and sufficient 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the description only needs to add context. It adds the USD currency restriction and the plan type scope, but does not disclose any additional behavioral traits such as rate limits or error handling. This is acceptable for a simple read 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 concise sentences that immediately state the purpose and input source. No redundant words or repetition of schema details.

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 read-only tool, the description covers the action, input, and scope. It does not explicitly describe the return value, but that is implied by 'get price' and there is no output schema to elaborate. Could be slightly more explicit about currency support, but that is already in the 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 baseline is 3. The description adds meaningful context by explaining that packageCode comes from any search result and that the plan can be either a data eSIM or phone-number eSIM, which supplements the schema's generic description.

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

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

The description clearly identifies the tool's function: retrieving the USD price for a specific plan, and explicitly scopes it to both data eSIMs and phone-number eSIMs. It also notes the input source (packageCode from search results), which distinguishes it from related pricing tools.

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

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

The description implies usage when you have a packageCode from a search result, but it does not explicitly state when to prefer this tool over alternatives like get_phone_plan_pricing or get_package_details. No exclusions or alternative recommendations are provided.

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

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

Annotations already declare readOnlyHint, and the description reinforces it with 'Read-only' and adds behavioral details: polling suitability, requirement of a connected agent wallet, and return contents (messages, status, expiry). This goes beyond the annotation without contradiction.

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 focused sentences front-load the core purpose, then efficiently cover usage, prerequisites, and return content. No unnecessary words or repetition of schema fields.

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

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

For a single-parameter read-only tool with rich annotations, the description fully covers what the tool does, when to use it, prerequisites, and what it returns. No output schema exists, so describing the response content is sufficient.

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

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

Schema covers 100% of the single parameter, and the description adds value by explaining where the receiptId originates (rent_sms_number or list_sms_orders), which is helpful context beyond the schema description.

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 reads the inbox of a long-term SMS rental, listing received messages newest first plus status and expiry. It distinguishes itself from siblings like cancel_sms_rental or list_sms_rentals by focusing on the inbox 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?

Provides clear when-to-use guidance: 'poll it when the user expects a message' and specifies the receiptId source. It lacks explicit exclusion of alternatives but gives sufficient context for correct selection among sibling rental tools.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the read-only nature is covered. The description adds valuable behavioral details beyond annotations: sorting by success rate, inclusion of VoIP/mobile distinction, and the bracket format for countryId to be used in order_sms_verification. No contradiction with annotations.

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

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

Two well-structured sentences front-load the core purpose, then add sorting and selection guidance, and finally mention the return format. Every sentence earns its place with zero redundancy or 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 list tool with one parameter and no output schema, the description fully conveys what the tool returns (country list with live price, success rate, VoIP status), how it's sorted, and how to use the output (bracket countryId for order_sms_verification). No critical information is missing.

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% (single serviceId parameter with description). The tool description does not add extra meaning beyond the schema, but since the schema fully documents the parameter, a baseline of 3 is appropriate. The description implicitly confirms that 'service' refers to the serviceId parameter.

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

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

The description clearly states the tool lists countries for one SMS service with specific attributes (price, success rate, VoIP status) and explicitly mentions the countryId bracket format for use with order_sms_verification. This distinguishes it from sibling tools like search_sms_services and check_country_coverage by focusing on country availability for a single service.

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: use this to get country options for a specific service before ordering. It even gives selection guidance ('prefer high success rates, prefer non-VoIP when the target service blocks virtual numbers'), but it does not explicitly name alternative tools or state when not 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?

Annotations already declare readOnlyHint=true, and the description adds meaningful context beyond that: it requires an agent-wallet API key (ak_live_), applies to existing eSIMs, and indicates output contains package codes with price/data. This is richer than merely restating the annotation, though it doesn't cover failure modes or response format.

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 serve a distinct purpose: what the tool does, when to use it, and a credential requirement. No redundant wording, and the key information is 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 one-parameter read-only tool with no output schema, the description covers purpose, usage sequence, output content, and API key requirement. It lacks explicit error/edge-case handling, but that is not essential for this level of complexity, making it 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?

The single parameter iccid is fully described in the schema with 'ICCID of the eSIM to get top-up options for'. The description adds marginal context by saying 'existing eSIM' and 'valid package codes', but the schema already carries the semantic weight, 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 ('List') and resource ('available top-up packages for an existing eSIM'), and specifies the output includes price and data amount. It also distinguishes this from the sibling topup_esim by showing how it fits into the workflow.

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 'Use this before topup_esim to find valid package codes', naming the exact alternative and giving a clear sequence. Also mentions the required API key type, which helps the agent decide when this tool is appropriate.

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

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

Annotations already declare readOnlyHint=true, and the description reinforces it with 'Read-only'. It adds useful behavioral context: ordering (newest first), the inline data limitation for fleets up to 8, and the wallet connection requirement. No contradiction with annotations.

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

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

Three dense, information-packed sentences. The first sentence front-loads the core action and output fields, followed by usage context and alternatives. No filler or repetition.

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

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

For a simple one-parameter read-only list tool, the description covers purpose, return fields, ordering, inline data caveat, prerequisites, and sibling distinctions. With no output schema, the field list compensates. Very 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% with the single 'page' parameter described as '1-based page (50 eSIMs per page)'. The description does not add parameter-specific semantics, 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 states a specific verb and resource: 'List every eSIM this wallet owns' with the fleet view and newest first. It clearly differentiates from siblings by mentioning get_esim_status for single eSIM detail and list_sms_orders for SMS numbers.

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: to answer 'which eSIMs do I own / how much data is left' without knowing an ICCID. Names alternatives: get_esim_status for single eSIM full detail, list_sms_orders for SMS numbers. Also notes the prerequisite of a connected agent wallet.

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?

Although readOnlyHint is already in annotations, the description adds valuable behavior: pagination, ordering (newest first), wallet-scoping, and authentication requirements. It also indicates what fields the response includes, which is useful given no output schema.

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

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

The description is two sentences and front-loaded with the core action and return fields. The second sentence adds usage guidance and constraints without fluff. Every sentence 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 simple two-parameter schema and read-only annotation, the description provides all necessary context: purpose, return fields, ordering, pagination, scope, auth, and use cases. The lack of an output schema is compensated by listing the returned fields. It is complete enough for an agent to select and 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 coverage is 100% with clear descriptions for page and limit. The description adds the word 'paginated' but does not explain parameter semantics beyond what the schema already provides. For a simple pagination setup, 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 tool 'Returns the order history for the connected wallet, newest first' and enumerates the exact fields returned (ID, package, status, cost, date, ICCID, install link). It distinguishes itself from siblings like list_esims and list_transactions by focusing on order history with wallet scoping.

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 lists concrete use cases: 'find a past purchase, retrieve an ICCID for get_esim_status, or show a user what they have bought.' It also provides important context like wallet-only scoping and auth requirements. However, it does not explicitly state when not to use this tool or mention 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?

Annotations already declare readOnlyHint=true, and the description reinforces 'Read-only.' It adds valuable behavioral context beyond annotations, such as requiring a connected agent wallet and the exact types of data returned for each order category, which helps set expectations for the agent.

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 tightly written in two sentences: the first explains what the tool lists and the fields returned, the second gives usage context and a prerequisite. No redundant words or filler, every sentence 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 (no parameters, no output schema), the description fully covers the return values by specifying the included data (Order IDs, receipt IDs, numbers, expiry dates). It also conveys the read-only nature, usage purpose, and wallet requirement, making it self-sufficient 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 has zero parameters, so the description has no parameter semantics to clarify. According to the rubric, a 0-parameter tool receives a baseline of 4, and the description does not need to compensate for any schema coverage gaps.

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 ('List this wallet's SMS orders') with a specific verb and resource. It distinguishes between quick verification orders and long-term rentals, and provides specific details about the returned identifiers (Order IDs, receipt IDs, numbers, expiry dates), setting it apart from sibling tools like list_orders and list_sms_rentals.

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 concrete use case ('re-find an order ID or check what is still active') and a prerequisite ('Requires a connected agent wallet'). While it doesn't explicitly name alternative tools or exclusionary conditions, the context is clear enough for an agent to determine when this tool is appropriate.

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

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

Annotations only state readOnlyHint and openWorldHint, but the description adds rich behavioral details: receive-only nature, fair-use limit of 25 SMS/day, live stock per duration with guidance to skip OUT OF STOCK, regional differences (US/UK real mobile, Canada VoIP), and prohibitions on banking/financial/crypto-exchange verification. This far exceeds expected disclosure.

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 distinct value: the first defines the resource and key operational traits, the second describes the output fields and stock interpretation, the third adds geographic and use-case restrictions plus the purchase link. No redundancy 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?

With no input schema parameters and no output schema, this description alone must convey enough for correct usage. It covers what the tool returns, how to interpret stock, special cases (VoIP), restrictions, and how to proceed after listing. This is fully adequate for a simple listing 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 tool has zero parameters, so the baseline is 4. The description correctly avoids inventing input details and instead focuses on output aspects (country, rentalId, duration tiers, prices, stock), which is useful for an agent setting expectations.

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 the verb 'List' and names the resource 'long-term SMS RENTAL numbers', making its function unambiguous. It also distinguishes from siblings like list_esims or list_orders by focusing on rental numbers and specifically mentions the purchase counterpart (rent_sms_number).

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

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

It clearly implies when to use it: whenever you need to list available long-term SMS rental numbers. The pointer to 'Purchase with rent_sms_number' indicates the typical follow-up action. However, it does not explicitly compare against alternatives like list_sms_orders, even though the self-descriptive name reduces ambiguity.

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

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

Annotations already declare readOnlyHint=true, and the description reinforces 'Read-only' while adding useful behavioral context: pagination, newest-first ordering, and filtering by type. It does not contradict annotations and adds value beyond them.

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

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

Two sentences, front-loaded with the core purpose and followed by usage guidance. No wasted words; every phrase adds 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?

Even without an output schema, the description explains what is returned (amount, running balance, description), the order (newest first), and pagination. For a read-only list tool with two optional params, this is 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% for both parameters (page and type) with their own descriptions. The tool description mentions pagination and filtering but does not add meaning 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 clearly identifies the tool as the wallet ledger listing all debits and credits with amount, running balance, and description, newest first. It distinguishes itself from siblings like check_balance by stating what it provides beyond a simple balance.

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 when to use it ('reconcile spend or answer "where did the balance go"') and names a specific alternative (check_balance) with its limitation ('only gives the current number'). This gives clear guidance.

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

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

Annotations only state destructiveHint=true and readOnlyHint=false, but the description adds rich specifics: wallet balance deduction ($0.50-$5), single-use, 20-minute validity, and auto-refund if no SMS arrives. This goes well beyond the binary hints and fully discloses the tool's 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?

Five sentences, each with a distinct purpose: purpose/flow, cost, lifecycle/refund, prerequisites, and wallet requirement. No redundancy, no fluff, and the most important action is 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?

Despite having no output schema, the description tells the agent the main return (a temporary phone number) and covers all critical operational aspects: cost, validity, refund behavior, prerequisites, and the need for a wallet. The idempotency key is documented in the schema, so the tool is effectively complete 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?

Schema coverage is 100% with detailed parameter descriptions for serviceId, countryId, and requestId (including idempotency semantics). The description reinforces that serviceId and countryId come from lookup tools, but it adds no new syntax or format details beyond the schema, so the baseline score of 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 opens with 'Buy a QUICK SMS verification number' – a specific verb and resource. It explains the flow (returns a temporary number, then read with check_sms_verification) and clearly distinguishes this ordering tool from sibling check/cancel tools.

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

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

Provides clear context: prerequisites (search_sms_services and get_sms_service_countries first), a wallet requirement, and the follow-up tool to use. It doesn't explicitly name alternatives, but the sequential guidance is unambiguous and sufficient for an agent to know when to invoke 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?

Annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=false. The description adds meaningful context by stating it deducts from the prepaid agent wallet, returns order details with activation info (ICCID, QR, SM-DP+), and requires an ak_live_ API key. No contradiction with annotations.

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

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

Four sentences, front-loaded with the primary purpose. It efficiently covers core usage, the special case for unlimited plans, the alternative for phone-number eSIMs, and a key prerequisite. Slight lack of structured formatting, but 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?

For a purchase tool with four parameters and no output schema, the description adequately covers purpose, side effects (wallet deduction), return contents (ICCID, QR, SM-DP+), and usage exceptions. Schema handles parameter details, making this sufficiently complete 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%, with each parameter fully documented in the schema. The description adds a high-level pointer to search_esim_packages and the days condition, but this mostly reiterates schema content. Baseline 3 is appropriate since the schema handles parameter semantics.

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

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

The description clearly states the primary action ('Purchase a DATA eSIM') and identifies the specific resource. It distinguishes itself from sibling tools by explicitly naming purchase_phone_plan for phone-number eSIMs and emphasizing data-only packages. The inclusion of wallet deduction and activation info further clarifies the tool's 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 explicit when-to-use guidance: for data eSIMs using packageCode from search_esim_packages, and for daily-reset 'Unlimited' plans requiring a days parameter. It also names the alternative tool (purchase_phone_plan) for phone-number eSIMs and mentions the required agent-wallet API key type. This gives clear context for tool 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?

The description discloses important behavioral traits beyond the annotations: it deducts from the prepaid agent wallet, requires an ak_live_ API key, and explains that the phone number is assigned later during network registration. This adds significant context beyond destructiveHint and readOnlyHint.

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 efficient, with each sentence adding useful information. It is front-loaded with the core purpose and includes necessary caveats. Slightly long but justified by 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?

Despite no output schema, the description covers return details (order details with ICCID, QR code, SM-DP+), prerequisites, side effects, and special activation cases. This is thorough for a purchase tool with this 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%, so parameters are well-defined. The description adds value by clarifying that packageCode comes from search_phone_plans and that activationDate is required only for specific plans, which is not fully explicit 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 identifies the tool as purchasing a PHONE-NUMBER eSIM with voice/SMS/data, distinguishing it from sibling tools like purchase_esim. It uses a specific verb (Purchase) and resource (phone-number eSIM), making its 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 clear when-to-use context: it instructs to use packageCode from search_phone_plans, warns about designated-date activation plans requiring activationDate, and states the API key requirement. While it doesn't explicitly name alternatives, the context is sufficient for appropriate 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?

Beyond the annotations (readOnly=false, destructiveHint=true, idempotentHint=false), the description discloses that it spends wallet balance, has fair-use limits (25/day), supports full refund within 2 hours if no messages arrived, and is extendable. This adds meaningful operational context without contradicting any annotation.

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 yet well-structured: it front-loads the core purpose, then covers cost, prerequisites, lifecycle, restrictions, and requirements. Every sentence adds essential information with no filler or repetition.

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

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

Given the tool's complexity (rental mechanics, idempotency, stock dependency, refund policy, forbidden uses) and the absence of an output schema, the description covers all critical operational aspects. It informs the agent of prerequisites, edge cases, and constraints sufficiently 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 already documents all three parameters at 100% coverage, including source of rentalId and the idempotency semantics of requestId. The description reinforces the tie to list_sms_rentals tiers and stock but does not significantly extend beyond schema descriptions, so the 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 opens with a specific verb and resource: 'Rent a LONG-TERM receive-only SMS number,' clearly distinguishing this from sibling tools like order_sms_verification or purchase_esim. It further clarifies the rental keeps the same number and allows multiple SMS, making the scope 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?

Provides explicit when-to-use guidance: call list_sms_rentals first for rentalId, day tiers, prices, and stock, and avoid out-of-stock tiers. Names lifecycle alternatives (extend_sms_rental, cancel_sms_rental) and states restrictions (not for banking/financial/crypto; requires connected wallet), exceeding basic usage instructions.

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

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

Annotations already declare readOnlyHint=true, and the description reinforces this with 'Read-only.' Beyond that, it discloses the return format (list with id, title, URL) and the follow-up action to fetch full details, which is valuable behavioral context not present in structured fields.

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

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

The description is two sentences, front-loaded with the main purpose, and every sentence adds meaningful information: scope, return format, and next step. No redundancy 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?

For a simple search tool with one parameter, good annotations, and no output schema, the description fully specifies the return format and how to proceed with the returned ids. It is complete for an agent to correctly invoke and use 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's query parameter already has a detailed description covering free-text and ISO country code examples (100% coverage). The tool description adds little beyond the schema for this parameter, so the baseline of 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 tool searches the PikaSim eSIM catalog explicitly covering both data eSIMs and phone-number eSIMs, and lists the return fields (id, title, URL). This specific verb+resource+scope distinguishes it from sibling tools like search_esim_packages or search_phone_plans.

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's a general catalog search covering both eSIM types, and it directs the agent to pass an id to the fetch tool for full details. It doesn't explicitly name alternative search tools or say when not to use it, but the scope statement implicitly differentiates it from more specific 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?

Annotations already declare readOnlyHint and openWorldHint, so the description doesn't need to restate safety. It adds valuable behavioral details: results are bucketed by product line, packageCode is shown in brackets for purchasing, and the 'type' parameter narrows to one line. This goes beyond what annotations provide.

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, front-loaded with the core purpose. Every sentence earns its place: search criteria, result structure, and narrowing instruction. 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?

Given this is a read-only search tool with 4 optional parameters and no output schema, the description is complete enough. It explains inputs, return structure (separate buckets), and the packageCode notation needed for purchasing. No critical invocation details are missing.

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 detailed descriptions for all four parameters (100% coverage). The description reinforces the search criteria (country, region, keyword) and mentions the 'type' narrowing, but does not add significant new meaning beyond the schema. 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 tool searches PikaSim eSIM plans by country code, region, or keyword, and explicitly distinguishes it from sibling tools by noting it returns BOTH product lines (DATA and PHONE-NUMBER eSIMs) in separate buckets. This makes the purpose 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 provides clear usage context: when searching eSIM plans by various criteria, and how to narrow results using the 'type' parameter. However, it does not explicitly mention alternative tools (e.g., search_phone_plans) or specify when not to use this tool, so it falls short of full exclusion guidance.

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

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

Annotations declare readOnlyHint=true and openWorldHint=true, which are consistent with the search behavior. The description adds meaningful behavioral details beyond annotations: real vs VoIP, AT&T/T-Mobile coverage for US, country list, and the packageCode return format. It does not mention pagination or rate limits, but for a search tool 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?

The description is three sentences: a clear definition, coverage/network details, and usage guidance. Every sentence adds distinct value without redundancy. Information is front-loaded with the core purpose, making it easy for an agent to quickly grasp the tool's role.

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

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

With no output schema, the description compensates by mentioning that results show packageCode in brackets for purchase_phone_plan. It also gives coverage scope and use-case context. It could be more complete by listing additional return fields, but for a search tool with openWorldHint, this is adequate for invocation and interpretation.

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 (query, region, country) having descriptive examples. The description itself doesn't add parameter-specific syntax or formats, but it does supply context like 'US for a real +1 number' indirectly through examples. Per the baseline rule, this is a 3.

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 searches for PikaSim phone-number eSIMs with real carrier numbers, differentiating them from data-only or VoIP plans. It explicitly distinguishes from generic search tools by specifying 'REAL carrier phone number (not VoIP)' and gives concrete regional examples.

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 when-to-use guidance: 'Use this when a user wants to call or text, not just data.' It also gives a when-not context ('not just data') and tips for the subsequent purchase step (packageCode). However, it does not explicitly name alternative tools for data-only plans, so it stops short of full alternative differentiation.

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

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

Annotations already declare readOnlyHint=true. Description adds return format ('service names with their serviceId in [brackets]') and the catch-all 'Other' behavior, which is useful beyond the annotation.

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 purposeful: purpose, product context, return format, usage tip, and next step. 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?

For a single-parameter search tool with no output schema, description explains purpose, return content, fallback for missing services, and recommends next step. Sufficient for an agent to select and invoke.

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

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

Schema covers the query parameter 100% with a clear description. The tool description does not add new parameter semantics, 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 states 'Search the SMS VERIFICATION service list' with a clear verb and resource, and specifies scope (websites/apps for receive-only numbers). It distinguishes from generic 'search' sibling by mentioning 'SMS product line'.

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 conditional guidance: 'If the target service is not listed, search "Other"' and a next-step pointer. However, it does not explicitly address when to use this versus sibling search tools.

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

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

The description adds critical behavioral details beyond the annotations: 'This SPENDS the wallet balance and cannot be undone' specifies the destructive impact, and 'Requires a connected agent wallet (OAuth or ak_live_ key)' adds auth requirements. It also clarifies that no new eSIM is issued, which is a key side-effect distinction.

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?

Five sentences, each essential: purpose, consequence, prerequisite, usage condition, and auth requirement. No fluff; information is front-loaded and well-organized.

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 an output schema, the description covers the action, side effects, prerequisite, usage scenario, and authentication. It also indirectly addresses error conditions via the schema's promoCode note. For a financial mutation tool, this 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?

Schema coverage is 100%, so baseline is 3. The description adds the workflow directive 'First call get_topup_options with the same ICCID to get valid top-up package codes and prices, then pass one here', which supplements the packageCode and iccid descriptions in the schema. It provides extra guidance on the relationship between parameters and the prerequisite call, elevating it 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 action: 'Adds more data... to an existing eSIM' and distinguishes it from purchasing a new one ('without issuing a new eSIM', 'rather than buy a new one'). It also differentiates from sibling tools like get_topup_options by specifying the top-up action itself.

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: 'Use when a user wants to extend an eSIM that is running low'. Provides a prerequisite and alternative: 'First call get_topup_options with the same ICCID... then pass one here'. The phrase 'rather than buy a new one' implies not using purchase_esim for this purpose.

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