x402card: Virtual Cards + Freeland eSIM

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

With no annotations provided, the description must fully disclose behavior, but it only says 'Return'. It does not clarify output format, response size, or whether this represents the same information as get_openapi. The phrase 'machine-readable' is a small hint, but not 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 a single, efficient sentence that directly states the tool's function. There is 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?

Given the simple nature (no params, no output schema), the description is minimal but lacks context about what the 'agent contract' actually contains or how it differs from other similarly named contracts. An agent would need more information to decide if this is the right 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 tool has zero parameters, so the input schema is empty and schema coverage is 100%. Per guidelines, a 0-parameter tool gets a baseline of 4, and the description does not need to explain any parameters.

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

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

The description uses a specific verb 'Return' and identifies a resource ('complete machine-readable x402card API/agent contract'), making the core purpose clear. However, it does not distinguish this tool from siblings like get_openapi or get_config, which could overlap in function.

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

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

There is no guidance on when to use this tool relative to alternatives. The description does not mention scenarios, prerequisites, or why one would choose get_agent_contract over sibling getters.

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

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It only says 'Return', which weakly implies a read operation, but does not state whether authentication is required, if it has side effects, or if it is idempotent. The description adds no behavioral context beyond what is inferred from the tool name.

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

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

The description is a single sentence, but it is dense with a long list of contract aspects (purchase, payer-ownership, issuance, economics, credential-security). While concise in word count, the readability suffers from the packed enumeration. A clearer structure (e.g., bullet points) could improve comprehension without sacrificing brevity.

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

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

Given the tool has no parameters and no output schema, the description lists several components of the contract, providing some context. However, it does not mention the return format, whether the contract is a JSON object or a string, or any authentication or preconditions. For a simple getter, this is adequate but not richly complete; the calibration for a comparable tool (get_calls) provides more context about scope and filtering.

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

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

The tool has zero parameters and schema description coverage is 100% (trivially). The description does not add parameter semantics because there are no parameters to describe. The baseline score of 3 is appropriate.

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

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

The description specifies the verb 'Return' and identifies the resource as a 'virtual-card direct x402 purchase, payer-ownership, issuance, economics, and credential-security contract'. This clearly distinguishes it from sibling tools like 'get_agent_contract' or 'get_esim_contract' by explicitly targeting the card contract.

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

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

The description provides no guidance on when to use this tool versus its siblings. It does not mention scenarios, prerequisites, or exclusions. For example, it could say 'Use this to retrieve the contract for a virtual card; for an agent contract use get_agent_contract.' The lack of such guidance makes it harder for an agent to choose correctly among the many get_* contracts.

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

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

With no annotations provided, the description alone must disclose behavioral traits. It indicates the tool returns a contract, and it lists specific components (top-up, ownership, amount, fee, replay, funding). However, it does not mention whether this is a read operation, if it requires any preconditions or authentication, or what happens if the contract does not exist. The description is adequate given the lack of annotations but could be more explicit about read-only behavior.

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

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

The description is a single sentence that concisely lists the elements of the contract. It is front-loaded with the main verb "Return" and no extraneous information. It earns its place, though it could be slightly more polished.

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 0 parameters and no output schema, the description is the primary source of information. It covers the purpose and what the tool returns, but it does not clarify the context (e.g., when to use this over sibling tools, or how the returned contract might be used). It is complete enough for a minimal tool but lacks contextual guidance.

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 0 parameters, so the description does not need to document any parameter behavior. Since schema coverage is 100% (there is nothing to cover), baseline is 4. The description adds value by explaining the specific nature of the contract, which goes beyond the empty 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 states it returns a "separate direct x402 card top-up, active-card ownership, amount, fee, replay, and asynchronous funding contract," which clearly identifies the resource and what the tool does (return a contract). It distinguishes itself from sibling tools like get_card_contract and get_esim_contract by specifying the unique elements of this contract.

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 does not provide any guidance on when to use this tool versus other contract retrieval tools (e.g., get_card_contract, get_agent_contract). No context is given about prerequisites, conditions, or limitations, leaving the agent to guess based solely on the name and description.

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

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

With no annotations, the description carries the full burden. 'Return' indicates a read-only operation and 'public' suggests no authentication is needed, but it does not explicitly state the absence of side effects, potential errors, or response format. Some additional behavioral detail would improve transparency.

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

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

The description is a single, front-loaded sentence that uses the verb 'Return' and lists specific config fields. Every word earns its place, with 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?

The tool is simple (0 params, no output schema), and the description provides a useful enumeration of returned fields. However, it lacks an explicit statement about the response structure or potential error conditions, which would make it fully complete for an unannotated 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 tool has zero parameters, so the description does not need to explain them. The baseline for 0 params is 4, and the description adds no parameter-related info because none exists.

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 'Return public runtime config' and enumerates the contents (network, USDC asset, receive address, fees, limits, treasury mode), making the tool's purpose unmistakable. It distinguishes itself from sibling tools like get_agent_contract and get_readiness by focusing on config data.

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 one needs public runtime configuration, but it does not explicitly state when to use this tool versus alternatives or provide any exclusion criteria. No alternatives are mentioned, leaving the guidance at an implied level.

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

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

With no annotations, the description carries the full transparency burden. It lists what the contract covers, giving some insight into the content, but it does not explicitly state that this is a read-only operation, mention any prerequisites or side effects, or describe the return format. 'Return' implies a safe read, but the description could be more explicit.

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

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

The description is a single sentence and relatively concise. However, the list of contract topics is somewhat awkwardly packed into one sentence ('catalog, direct x402 purchase, payer-ownership, fulfillment, and privacy contract'), which could be restructured for better readability but is still 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 zero-parameter, no-output-schema tool, the description provides a reasonable overview of what the contract covers. It lists the major aspects, giving an agent enough context to understand the tool's purpose. It does not explain the return format, but the absence of parameters and output schema means less is needed. It is complete enough for a simple contract retrieval.

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 there is nothing to describe. Per the calibration, a zero-parameter tool receives a baseline score of 4. The description does not need to add parameter context since none exist.

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 Freeland eSIM contract and lists its key topics (catalog, purchase, ownership, fulfillment, privacy). It is specific about the resource but does not explicitly differentiate from sibling tools like get_agent_contract, though the 'Freeland eSIM' qualifier helps narrow it down.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as get_esim_readiness or get_agent_contract. There is no mention of scenarios where this contract would be needed over other 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?

With no annotations, the description carries the full transparency burden. It discloses key behavior by stating that the readiness check excludes unrelated card-provider and treasury gates. Yet it omits details about return type or potential errors, which are not covered elsewhere.

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

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

The description is a single sentence that is front-loaded with the main action ('Return eSIM-only readiness') and includes no extraneous content. Every word contributes to understanding the tool's purpose and scope.

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 tool with no output schema, the description is nearly complete. It clearly indicates what is returned and what is excluded, but could more explicitly describe the return value shape (e.g., boolean vs. object), which would aid agent expectations.

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

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

The tool has zero parameters, so there is no parameter-specific information to add. The baseline for zero-parameter tools is 4, and the description appropriately provides no irrelevant parameter details.

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

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

The description clearly states the tool 'Return eSIM-only readiness' with a specific verb and resource. The qualifier 'without unrelated card-provider or treasury gates' effectively distinguishes it from the sibling get_readiness tool.

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

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

The description implies its use case by focusing on eSIM-only readiness and explicitly excluding card-provider and treasury gates. However, it does not name the alternative get_readiness or provide explicit when-to-use/when-not-to-use guidance.

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

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

With no annotations, the description carries the burden of explaining behavior. It clearly states what the tool returns (shell install command and CLI discovery commands), which is the primary behavioral trait. It does not mention side effects, but given the nature of the tool, that 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 a single, direct sentence with no filler. It is front-loaded with the key action and resource, and every word contributes to 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?

For a simple tool with no parameters, no annotations, and no output schema, the description fully covers what the agent needs to know. It explicitly names the two types of output (shell install command and CLI discovery commands), making the tool's purpose and result clear.

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 of 4 applies. The description does not need to explain parameter semantics because there are none, and the schema already indicates no properties.

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 a shell install command and CLI discovery commands, with a specific verb (Return) and resource. This distinguishes it from sibling tools that retrieve contract details, configs, or readiness.

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

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

The description implies the tool is for obtaining installation instructions, but provides no explicit guidance on when to use it versus alternatives or any exclusion criteria. The usage is understandable from context but not directly articulated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It accurately states the tool returns a document, implying a read-only operation, but does not mention any authentication requirements, rate limits, or whether the document is dynamically generated. For a simple getter, this is minimally sufficient but leaves some ambiguity.

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

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

The description is a single, front-loaded sentence with no redundant words. It fully states the tool's purpose without any filler or repetition of the tool name.

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

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

Given the tool's simplicity (no parameters, no output schema), the description is nearly complete: it tells the agent exactly what is returned and for what purpose. It could add a note about the response format (JSON vs YAML) but that is a minor gap. Overall, it is sufficient for an agent to select and invoke the tool correctly.

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

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

The input schema has zero parameters and is covered 100% by the schema (which is empty). Per the baseline for 0-parameter tools, a score of 4 is appropriate. The description does not need to explain parameters since there are none, and it adds no param-related information 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 specifies the action ('Return') and the resource ('the OpenAPI 3.1 document'), with an additional qualifier ('for direct HTTP API usage') that sharpens the scope. It distinguishes this tool from siblings like get_agent_contract or get_config, all of which return different types of documents.

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

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

The phrase 'for direct HTTP API usage' provides clear context that this tool is the entry point for obtaining the API specification when one intends to interact with the HTTP API directly. It does not explicitly name alternatives or add exclusions, but the purpose is specific enough that an agent can confidently choose it when needing the OpenAPI document.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does not mention side effects, permissions, error behavior for invalid or missing order IDs, or the nature of the returned URL. 'Build' hints at a pure function but this is not confirmed.

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

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

The description is a single well-structured sentence that front-loads the action and resource. Every word earns its place with no redundancy.

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

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

For a single-parameter tool with no output schema and no annotations, the description provides a basic understanding of purpose and input but lacks details on return value format, error conditions, or security implications. It is sufficient for a simple build operation but not fully complete.

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

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

The schema has no description for orderId and the description adds the qualifier 'existing', which is useful. However, it does not explain the format of the order ID, how to obtain it, or any validation rules, leaving the parameter semantics minimally enriched.

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 'Build' with a clear resource 'public payable x402 URL' and scope 'for an existing order id'. It unambiguously distinguishes itself from sibling getter tools by being the only tool that constructs a URL.

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

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

It clearly states the prerequisite that the order id must be existing, implying usage is for generating a payable URL after an order is created. However, it does not explicitly discuss when not to use it or mention any alternative tools, though the siblings are mostly unrelated getters.

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

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

With no annotations, the description carries the full burden. It discloses that the output is sanitized and that deep/restricted data is not accessible via this tool, which is valuable transparency. It does not mention side effects, auth, or rate limits, but for a read operation this is acceptable.

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

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

The description is a single, concise sentence that gets straight to the point without unnecessary words. It efficiently conveys purpose and an important restriction.

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

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

For a simple tool with one optional parameter, the description is mostly adequate but leaves ambiguity about what 'readiness' actually represents and what the 'deep' parameter controls. It could also briefly clarify the return format or intended use case.

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 one optional boolean parameter 'deep' with 0% description coverage, yet the description does not explain what 'deep' does or how it relates to the admin-only mention. The description fails to add any meaning beyond the schema for this 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 'Return sanitized public readiness' with a specific verb and resource, and it distinguishes itself from admin-only deep details. It does not explicitly differentiate from sibling tools by name, but the contrast with admin-only info implies a distinct scope.

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

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

It provides context that deep provider balances and BIN internals are admin-only, implying this tool should be used for public readiness and not for deep details. This offers a clear exclusion but does not explicitly name alternative tools, making it slightly less explicit than ideal.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It describes what is returned but does not state whether the operation is read-only, requires authentication, or has side effects. It also does not clarify the structure or meaning of the requirements, leaving significant behavioral ambiguity.

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

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

The description is a single, compact sentence that immediately conveys the core purpose. It is front-loaded with the verb and resource, and every word adds information. There is no waste.

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 tool with no output schema, the description gives a high-level list of what is returned, which is adequate but thin. It leaves unclear aspects like the exact format or how these requirement categories interrelate. The presence of sibling tools and the lack of usage guidance also reduce contextual completeness.

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

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

The tool has zero parameters, so there is nothing for the description to explain about parameter semantics. Per the baseline for 0 parameters, this scores a 4. The description correctly avoids inventing parameters and focuses on the output.

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 wallet requirements, enumerating specific categories (owner authentication, x402 payer, credential, adapter). The verb 'Return' is specific, and the resource is evident from the tool name and description. It distinguishes itself from sibling tools by focusing on requirements rather than configuration or contracts, though the jargon-heavy phrasing could be clearer.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention any use cases, prerequisites, or exclusions. With several sibling get_* tools, an agent would benefit from context on when wallet requirements are needed, but no such guidance is provided.

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

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

With no annotations, the description carries the transparency burden. It adds 'live' and 'current' to indicate real-time freshness, which is useful, but it does not disclose how the optional filters affect results, whether all plans are returned by default, or what the response structure looks like.

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

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

The description is a single, front-loaded sentence with no redundant information. It earns its place by stating exactly what the tool does.

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

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

The tool has optional parameters and no output schema, yet the description fails to explain how the parameters work or what data will be returned. For an agent to invoke it correctly, more detail is needed on filtering behavior and response contents.

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

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

The description provides zero explanation of the 'type' and 'countryCode' parameters, and the schema has no descriptions (0% coverage). An agent cannot infer what enum values 'country' or 'region' mean or how countryCode constrains results, making this a critical gap.

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

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

The description clearly states the tool lists live Freeland prepaid travel eSIM plans and current Base USDC prices, using a specific verb ('List') and resource. It distinguishes itself from sibling get_* tools by being the only list_* operation.

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

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

Usage is implied by the name 'list_esim_plans' and the description, but there is no explicit when-to-use guidance or mention of alternatives. The lack of direction on optional parameters makes it less clear when to pass type or countryCode.

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