esimgomobile — Travel eSIM Tools

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

Annotations already declare this a read-only, idempotent, non-destructive, closed-world operation, so the safety profile is covered. The description adds useful provenance context ('which the user's phone reports exactly'), telling the agent the inputs are user-supplied readings, but says nothing about the projection's assumptions or failure modes.

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 trigger condition, then the computed outputs. No filler and nothing repeated from the schema or annotations.

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

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

An output schema exists, so return values need no explanation, and annotations cover the safety profile. What remains thin is differentiation from estimate_data_usage and any note on how the projection is derived.

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 schema already documents all four parameters including where the user finds used_gb. The description only gestures at 'plan size and usage so far' and leaves days_total/days_elapsed to the schema's 'daily budget' phrasing, so it adds little beyond structured data.

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?

States a specific verb and outputs: 'Computes remaining data, daily budget and end-of-trip projection' from plan size and usage. That is clear and concrete, but the nearby sibling estimate_data_usage is never distinguished from it, so an agent cannot be fully certain which to pick.

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?

'Use when the user asks how much of their plan data is left or how to ration it over a trip' gives an explicit triggering condition. It stops short of naming a when-not case or the alternative tool (estimate_data_usage), so routing is implied rather than complete.

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 a read-only, idempotent, non-destructive operation, so the description does not need to repeat safety properties. It adds useful context by clarifying that the home-carrier rate is user-supplied and the travel-eSIM rate is illustrative, which helps the agent interpret the comparison.

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 tightly written sentences, with the usage trigger front-loaded and the comparison behavior immediately following. There is no redundant or filler language.

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

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

For a simple two-parameter read-only calculator with a full input schema and an output schema, the description supplies the key behavioral caveat: the travel-eSIM rate is illustrative. It gives the agent enough context to select and invoke the tool appropriately without over-explaining return values.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema. The description reinforces the meaning of the home-carrier daily rate and mentions trip days implicitly through the comparison, but it does not add substantial parameter detail 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 gives a specific comparison task: home carrier roaming fees versus a travel eSIM, using a user-supplied day-pass rate and an illustrative eSIM daily rate. It is more precise than the name alone, but it does not explicitly distinguish this tool from nearby siblings such as compare_plans or calculate_data_budget.

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 when to use the tool: when the user wants to compare home-carrier roaming fees against a travel eSIM. It does not provide when-not-to-use conditions or name alternative tools, so it falls short of the top score.

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 read-only, idempotent, closed-world, and non-destructive behavior, so safety is covered. The description adds that it 'walks through the check on iPhone and Android,' indicating a platform-specific guide format, but does not disclose further behavioral details such as output format or limitations.

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 with no wasted words. The usage condition is front-loaded, followed immediately by the platform-specific detail.

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 check with an output schema and rich annotations, the description provides sufficient context: what it checks, why it matters, and what platforms it covers. Nothing critical 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?

The tool takes zero parameters, so the schema itself has no semantic burden. The description correctly adds no parameter details, and the baseline for zero-parameter tools is 4.

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

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

States a specific verb and resource: 'check whether their phone is carrier-unlocked.' The mention of travel eSIMs gives context, but it does not explicitly differentiate from sibling tools like check_device_compatibility or troubleshoot_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?

Opens with 'Use when the user needs to check...' which clearly identifies the triggering scenario. It does not name alternative tools or conditions where a different check would be more appropriate, so it stops short of full when-not guidance.

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

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

Annotations already declare this a read-only, idempotent, non-destructive, open-world call, so the safety profile is covered. The description adds genuinely useful context beyond that: the answer comes from esimgomobile's published plan catalog and is live-checked, plus a built-in country network reference, which tells the agent about data provenance and freshness.

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

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

Two short sentences, with the usage trigger front-loaded before the data-source explanation. No filler or restatement 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?

An output schema exists, so return values need not be explained. The description covers purpose, trigger, and data provenance for a single-parameter lookup; only minor gaps remain, such as whether the answer reflects plan-specific or network-level coverage.

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?

One required parameter with 100% schema description coverage and an inline example ("Japan"), so the schema already does the work. The description implies the country argument but adds no format, accepted-value, or naming detail beyond what the schema provides.

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

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

States a specific verb (check) and resource (country coverage) scoped to esimgomobile plans, which distinguishes it from generic siblings like list_country_networks or search_plans. It stops short of naming the adjacent sibling that also answers coverage questions, so differentiation is implied rather than explicit.

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?

"Use when the user asks whether a country is covered" gives an explicit, recognizable trigger condition. There is no when-not guidance, no named alternative for overlapping coverage/plan questions, and no prerequisite stated.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds the mechanism (built-in device table plus a manual fallback check), which is useful, but it never says what happens for an unrecognized model or how a fallback is surfaced. Adequate but not rich.

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

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

Two short sentences with no filler; the use-trigger is front-loaded and the mechanism follows. Nothing is wasted, though it is terse rather than optimized.

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

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

This is a low-complexity, single-parameter read tool with an output schema, so return values need not be explained. The description covers the trigger and the lookup mechanism, leaving only edge-case behavior (unknown model) unstated.

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

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

Schema description coverage is 100% and the single parameter has a clear description with concrete examples ('iPhone 13', 'Galaxy S23'). The description adds no naming or format guidance beyond the schema, 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?

States a clear verb and resource: checks a phone's model against a built-in device table for eSIM support. An agent can distinguish this from siblings like check_carrier_lock or troubleshoot_esim. It does not explicitly name a sibling it is not, but the scope is specific enough to stand on its own.

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?

"Use when the user asks whether their phone supports eSIM" is an explicit, concrete trigger that maps to a real user intent, which is strong guidance. It lacks any when-not condition or named alternatives, so it falls short of the top band.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so safety is covered. The description adds genuinely new behavioral context: the check is a 'guided manual check' and browsers cannot run automatic DNS probes, which sets correct expectations that output is instructions rather than an automated verdict.

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 usage trigger and followed by the key behavioral caveat. No filler or repetition of the title.

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

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

An output schema exists, so return values need not be described. Combined with annotations covering the safety profile and the description covering the manual/procedural nature, nothing an agent needs in order to invoke this correctly 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?

The tool takes zero parameters, which establishes the baseline of 4 per the rubric. The description correctly implies a parameterless invocation, adding nothing that could mislead about inputs.

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

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

The description names a specific verb+resource: checking whether DNS queries leak outside a VPN. It is clearly distinguishable from siblings like get_public_ip or check_internet_freedom, though it does not explicitly name those alternatives. The purpose is unambiguous without opening the schema.

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

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

It opens with an explicit trigger condition: 'Use when the user wants to check whether their DNS queries leak outside their VPN.' This is a clear use context. It stops short of naming alternatives or exclusions, so it doesn't reach the top of the scale.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world). The description adds genuine behavioral context beyond that: results come from a static built-in table rather than live probing, and the output is explicitly not legal advice. It stops short of describing freshness or coverage limits of that table.

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

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

Two short sentences, front-loaded with the usage trigger and followed by the nature of the return value. Every clause carries information; nothing is redundant padding.

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 lookup with an output schema and full annotation coverage, the description supplies everything needed: when to use it, what it returns conceptually (a high-level snapshot), its data source, and its limitations. No material gap remains.

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

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

Schema description coverage is 100% and the single 'country' parameter is already documented with an example ("Country, e.g. UAE"). The description adds no format, matching, or naming conventions beyond the schema, 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 states a specific verb and resource — checking internet restrictions (VoIP blocks, firewalls) in a country — and signals the answer comes from a built-in table, which an agent can distinguish from live-measurement siblings like run_speed_test or check_dns_leaks. It does not explicitly differentiate from adjacent lookup tools such as get_country_fact_sheet or list_country_networks, which slightly caps the score.

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?

"Use when the user asks about internet restrictions in a country" gives a clear trigger condition for invocation. There are no explicit exclusions or named alternatives, but the triggering context is unambiguous.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint=false, and destructiveHint=false. The description adds the comparison logic but no permissions, rate limits, or side-effect details 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?

Two short sentences, front-loaded with the primary use case and the comparison mechanism. No redundant or filler text.

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

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

For a simple two-parameter, read-only tool with a complete input schema and an output schema, the description provides the needed context: what it does and when to use it. Nothing critical 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 description coverage is 100% with both required parameters fully described. The description alludes to home_country and current_country but adds no extra format or constraints 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?

States a specific verb (check) and resource (roaming status) and explains the mechanism: compares home country to current country. It does not differentiate from siblings like calculate_roaming_cost, but the purpose is clear.

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

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

Explicitly says 'Use when the user wants to know whether they are currently roaming,' giving a clear trigger. It does not mention when not to use or name alternative tools (e.g., calculate_roaming_cost).

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

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

Annotations already declare readOnly, idempotent, non-destructive, openWorld, and an output schema exists for the return shape. The description adds that a 'best-value pick' is computed, which is mild behavioral value, but says nothing about how ties are broken, pricing freshness, or any rate/auth considerations.

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?

Front-loaded with the usage trigger, then a compact list of compared fields. The trailing 'No competitor API offers this' is marketing filler that does not help an agent decide or invoke anything.

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 full schema coverage, rich annotations, and an output schema covering the return payload, the description supplies what an agent needs to call it correctly. Only the sibling disambiguation 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 description coverage is 100% and the single plan_ids parameter is fully documented with minItems/maxItems and a pointer to search_plans. The description's '2-4 plans' merely restates the schema constraint, so baseline 3 applies.

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

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

States a specific verb ('compare') and resource ('esimgomobile plans') and enumerates the comparison dimensions (price, data, validity, scope, per-GB unit price) plus a best-value output. It never contrasts itself with close siblings like recommend_plan or get_plan_details, so the agent may struggle to disambiguate, but the purpose itself is unambiguous.

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

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

'Use when the user is choosing between 2-4 esimgomobile plans' gives a clear triggering condition and a quantity bound. It stops short of naming alternatives (e.g., recommend_plan for open-ended recommendations, get_plan_details for a single plan), which is the only gap.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world behavior, so the safety profile is covered. The description adds genuinely new behavioral context with 'step-by-step guided check — no automatic probing', telling the agent this tool guides the user rather than issuing network requests itself. This is useful and non-redundant, though it could say more about what the guided check entails.

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, both earning their place: the first front-loads the usage trigger and the second discloses the non-probing behavior. There is 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?

An output schema exists, so return values need not be described, and with zero parameters the definition only needs purpose, trigger, and behavior — all present. It is slightly incomplete in omitting what the guided check steps involve and any alternative tools, but it is adequate for a parameterless, read-only diagnostic.

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 takes zero parameters and schema coverage is 100%, so there is nothing for the description to compensate for. Baseline 4 applies; no parameter explanation is needed or expected.

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

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

The description names the resource (captive portal / login page) and the action (step-by-step guided check), and the 'no automatic probing' clause implicitly separates it from probing siblings like run_speed_test, measure_latency, and get_public_ip. It is clear, though the core verb is softer than a crisp 'detect' statement and no sibling is named explicitly.

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 trigger condition is stated concretely: use when the user is on hotel/airport/cafe Wi-Fi and suspects a login page is blocking them. That is a clear context for use. It does not name any alternative tool or state when not to use it, so it falls short of a 5.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and closed-world scope, so the safety profile is covered. The description usefully adds that the tool both computes an estimate and suggests a plan size, but says nothing about estimation model, rounding, or plan catalog assumptions.

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 trigger condition, then the computation and output. Nothing is redundant and it is appropriately sized for a three-parameter estimator.

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

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

With an output schema present, the description needn't explain return values, and it still names the plan-size suggestion. It covers inputs and trigger adequately; the only gap is the unaddressed relationship to calculate_data_budget and recommend_plan.

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

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

Schema description coverage is 100% and all three parameters are required with an enum on usage_profile, so the schema does the heavy lifting. The description merely restates the parameters (trip days, daily hours online, light/moderate/heavy) without adding format, range, or edge-case 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?

States a specific verb and resource ("estimates" data usage) plus its three inputs and the plan-size recommendation it emits. However, it never distinguishes itself from the similarly-purposed sibling calculate_data_budget, so an agent cannot resolve the overlap from the description alone.

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?

"Use when the user is planning a trip and asks how much mobile data they need" gives a clear triggering condition and even the user's phrasing. It lacks any exclusion or pointer to the look-alike sibling calculate_data_budget, so the when-not guidance is absent.

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

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

Annotations already declare read-only, idempotent, non-destructive, and closed-world behavior. The description adds genuinely non-redundant context: the ranking comes from the OpenCelliD dataset and is a coverage proxy rather than a speed measurement, which guards against misinterpreting results.

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: the trigger condition first, then the methodology and its key limitation. No filler, and the most decision-relevant 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?

With an output schema present, return values need not be explained. Purpose, trigger, data source, and the coverage-proxy caveat combined with annotations make the definition sufficient 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 both required parameters documented and exemplified ('City, e.g. Tokyo', 'Country, e.g. Japan'). The description adds no parameter-level detail beyond the schema, so the baseline 3 applies.

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

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

States a specific outcome — ranking mobile operators as 'best' for a given city — and describes the actual ranking basis (observed cell-tower density). This clearly separates it from coverage-checking siblings, but it never names a sibling tool to route against, leaving differentiation implicit.

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 opening clause 'Use when the user asks which mobile network is best in a specific city' is an explicit trigger condition. It gives no when-not guidance or named alternative (e.g., check_coverage, list_country_networks) for adjacent questions.

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, openWorldHint, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds meaningful context beyond that: results come from a live, community-mapped external directory, implying data freshness and coverage gaps the agent should caveat. It doesn't mention rate limits or failure modes.

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, zero filler, with the invocation trigger front-loaded before the implementation detail. Every clause earns its place.

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

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

For a one-parameter read-only lookup with an output schema, the definition supplies the trigger, the data provenance and the safety profile via annotations. Nothing needed to call it correctly 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% for the single 'city' parameter, so the baseline is 3. The description adds only a spatial nuance ('near the city') beyond the schema's 'City to search in', which does not materially extend parameter meaning.

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?

States a specific verb+resource (find free Wi-Fi hotspots) plus the data sources it queries (Nominatim geocoding + Overpass via OpenStreetMap), which no sibling tool does. An agent can distinguish it from the connectivity/plan-oriented siblings at a glance.

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?

Opens with an explicit trigger: 'Use when the user asks where to find free Wi-Fi in a city.' It gives clear context for invocation but names no exclusions or alternative tools for adjacent asks (e.g. Wi-Fi security vs. hotspot lookup).

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world behavior, so the safety profile is fully covered. The description adds that a built-in dialing-code table is used, hinting at deterministic offline behavior, but that largely restates openWorldHint=false and gives no detail on output format or error cases.

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 with zero padding: the usage trigger is front-loaded, followed immediately by the mechanism. Every clause earns its place.

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

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

With a full output schema, return values need no explanation, and the three required params are schema-documented. The description is adequate for a simple pure-function tool, though it could note country-format expectations.

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

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

Schema description coverage is 100%, so all three parameters (from_country, to_country, phone_number) are already documented in the schema, including the local-format example. The description adds no extra meaning such as accepted country formats or number normalization rules, so baseline 3 applies.

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

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

States a specific verb+resource ('Formats a local phone number') and the scope ('calling between two countries'). No sibling tool overlaps with phone-number formatting, so ambiguity is low, but the description never explicitly differentiates itself from siblings.

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

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

Opens with an explicit usage cue ('Use when the user needs to dial a local number internationally'), which gives clear context for invocation. It offers no exclusions or named alternatives, but no sibling is close enough to require routing guidance.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world behavior, so the safety profile is covered. The description adds real value beyond that by disclosing the answers come from a 'researched dataset' rather than live lookups, and that coverage is limited to 'major international airports'.

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

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

Two sentences, no filler, with the usage trigger front-loaded before the content description. Every clause earns its place.

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

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

An output schema exists, so return values need not be described, and the single parameter is fully documented in schema. The description covers scope and data provenance; the only minor gap is what happens for airports outside the 'major international' set.

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 airport_code parameter, and the schema itself documents the IATA format with an example. The description adds nothing about the 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?

States a specific verb/scope: answering connectivity questions (Wi-Fi, SIM vendors, eSIM) for an airport, sourced from a researched dataset of major international airports. This clearly separates it from generic siblings like find_free_wifi or lookup_apn_settings. It does not explicitly name those siblings, so it stops short of a 5.

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

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

The opening 'Use when the user asks about connectivity at an airport' gives a clear triggering condition tied to the resource. There is no explicit when-not guidance or named alternative (e.g., use find_free_wifi for non-airport Wi-Fi), so it is solid but not exhaustive.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and openWorldHint=false. The description reinforces and extends this by disclosing the data source (a built-in table) and, importantly, fallback behavior for unlisted countries (general guidance rather than an error) — real context not present in the 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?

Two tight sentences with no filler; the trigger leads and the behavior follows. The what-it-does statement is deferred to the second sentence, a minor structural nit rather than 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?

An output schema exists, so return-value detail is not needed, and annotations carry the safety profile. Trigger, source, and unlisted-country fallback are all covered; the only real gap is routing against overlapping siblings such as list_country_networks.

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

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

With one parameter at 100% schema description coverage, the schema already documents "country" with an example. The description adds nothing about expected format (ISO code vs. name), aliases, or ambiguity handling, so baseline 3 applies.

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

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

The description names a specific resource (a country fact sheet covering mobile networks, eSIM support, Wi-Fi) and a concrete trigger, so an agent can tell what it returns. However, it never distinguishes itself from close siblings like list_country_networks, check_coverage, or find_free_wifi, which cover overlapping ground.

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?

"Use when the user asks about mobile networks, eSIM support, or Wi-Fi in a country" is an explicit, actionable trigger. There is no when-not guidance or alternative routing despite significant overlap with network-listing and coverage-checking siblings, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is fully covered by structured data. The description's added content ('Covers iPhone and Android, via QR code or manual entry') merely restates the two enum parameters rather than disclosing anything new about behavior. With an output schema present, no return-value explanation is required, so a baseline 3 is right.

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

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

Two short sentences, zero filler, with the trigger condition front-loaded and the coverage scope second. Every clause earns its place.

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

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

This is a simple read-only, closed-world, idempotent lookup with two fully documented enum parameters and an output schema, so the description covers what an agent needs to invoke it. It could be marginally stronger by stating the sibling boundary against troubleshoot_esim, but nothing essential 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 description coverage is 100% and both parameters are enums with constrained values, so the schema carries the parameter burden. The description's mention of iPhone/Android and QR/manual maps directly onto those enums without adding format or usage nuance. Baseline 3 applies.

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

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

The description names a specific resource (step-by-step eSIM installation instructions) and a clear trigger verb ('Use when the user needs...'), so an agent knows exactly what it returns. It does not, however, differentiate itself from close siblings like troubleshoot_esim or setup_dual_sim, which an agent could plausibly confuse with an install-instruction request.

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 'Use when...' clause gives a clear selection condition tied to the user's need for installation instructions. There is no explicit when-not guidance or named alternative (e.g., route troubleshooting problems to troubleshoot_esim), so it stops short of the top score.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is fully covered without the description. The description's remaining content is a list of returned fields, which overlaps the existing output schema rather than adding behavioral context like auth needs, error behavior, or rate limits.

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

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

A single sentence, front-loaded with the usage trigger and then the returned attributes. Every clause carries information and there is no filler.

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

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

With one required parameter fully documented, annotations covering the safety profile, and an output schema that handles return values, the description covers what an agent needs to select and call the tool. The only minor gap is that the returned-field list duplicates the output schema instead of spending that space on disambiguation from siblings.

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

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

Schema description coverage is 100% and the single plan_id parameter is documented with an example value and a pointer to search_plans for ids. The description adds no format or constraint detail beyond the schema, 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 names a concrete verb ('get details') and a precisely scoped resource ('one specific esimgomobile plan by id'), and enumerates the attributes returned. The singular 'one specific plan by id' implicitly separates it from the plural browse tools (list_available_plans, search_plans), though it never names a sibling explicitly.

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 leading clause 'Use when the user asks about one specific esimgomobile plan by id' is an explicit trigger condition, and the 'by id' qualifier implies it is not for browsing or comparison. There is no explicit when-not clause or named alternative, so it falls short of a 5.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds genuine context beyond that by explaining the returned value is the egress address observed at the server edge, which tells the agent the result depends on the caller's network path. It does not mention rate limits or caching, but little else is needed for a zero-argument read.

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

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

Two sentences, no filler, with the usage trigger front-loaded and the return semantics immediately after. Every clause earns its place.

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

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

For a trivial zero-argument lookup with rich annotations and an output schema, the description supplies both the selection trigger and the meaning of the response. Nothing an agent needs in order to call or interpret it 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?

The tool takes no parameters, so the baseline is 4 and there is nothing for the description to disambiguate. It correctly avoids inventing parameter detail that does not 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?

States a specific verb and resource ('Returns the IP address the request arrives from') and clarifies the vantage point ('as seen by the server edge'), which is exactly the ambiguity an agent would otherwise have to guess at. No sibling in the list returns a public IP, so it is trivially distinguishable from calculate_*, check_*, or lookup_* 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?

Explicitly names the trigger: 'Use when the user asks for their public IP address.' That is clear context, but there is no when-not guidance or named alternative for near-synonyms such as check_dns_leaks or get_country_fact_sheet, which also surface network identity information.

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

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

Annotations already declare readOnlyHint/idempotentHint/destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds valuable context beyond that: it performs no new queries but 'composes the built-in references,' i.e., an aggregation over existing country/freedom/device/install data, and it lists the sections returned. Return format details are left to the output schema, which is fine.

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

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

Two sentences, no waste: the trigger condition is front-loaded, followed by the scope enumeration and the composition note. Every clause earns its place.

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

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

An output schema exists, so return values need not be explained, and the description covers the trigger, scope, and aggregation semantics. For a read-only composite tool with fully documented parameters, nothing an agent needs to select or invoke it 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 description coverage is 100%, so all three parameters (country, os, device_model) are already documented in the schema, including the ios default and the enums. The description only implicitly maps 'device check' and 'install steps' to device_model and os, adding marginal meaning. 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?

Names a specific resource (a data-related trip checklist) and enumerates exactly what it covers: networks, eSIM support, internet freedom, device check, install steps. It also states it 'composes the built-in country, freedom, device and install references,' which distinguishes it clearly from the many leaf siblings like check_device_compatibility or check_internet_freedom.

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?

Gives an explicit trigger: 'Use when the user is preparing a trip and wants one pass over everything data-related for a country.' This implies it is the aggregate alternative to invoking the individual check tools. There is no explicit when-not-to-use statement, but the composition sentence effectively signals that leaf tools are the alternative for narrower needs.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description adds only that the output is a practical checklist, without noting any behavioral caveats, so it adds modest value beyond the 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?

Two short sentences with the trigger front-loaded ahead of the output description. Nothing wasted, nothing padded.

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-argument tool with a full output schema and complete annotations, the definition supplies adequate context for correct invocation. Only the lack of explicit sibling differentiation keeps it from being 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?

Tool takes zero parameters, so there is no parameter semantics to document; baseline for a 0-param tool is 4.

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

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

States a specific verb + resource (returns a practical safety checklist) and scopes it to Wi-Fi security. It is clearly distinct from most siblings, though it doesn't explicitly differentiate itself from the similar get_travel_data_checklist.

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?

Gives an explicit trigger condition: use when the user is about to connect to public, hotel, or airport Wi-Fi. It does not name alternatives or when-not-to-use, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile needs no restating. The description usefully adds what the operation produces (a four-tier grade plus practical advice), which is behavior beyond the annotation set.

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, zero filler, trigger condition front-loaded before the effect. Nothing is repeated between the sentences.

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?

A simple read-only, closed-world tool with three required numeric params and full schema coverage; an output schema exists, so return values need no explanation. The description still names the grade tiers and the actionable advice, leaving nothing an agent needs in order to call it correctly.

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

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

Schema description coverage is 100% and each property already documents its unit (ms, Mbps), so the schema carries the parameter burden. The description merely echoes 'download/upload speed and ping numbers' without adding expected ranges, units nuance, or a note on which measurement source to use.

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?

Names a specific verb (grades) and resource (connection quality) and states the output scale (Excellent/Good/Fair/Poor). It implicitly separates itself from measurement siblings like run_speed_test and measure_latency by grading numbers the user already has, but it never names those alternatives explicitly.

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 opening clause gives a concrete trigger: the user supplies download/upload/ping numbers and wants a verdict. That is a clear usage condition, though it gives no exclusion rule for the case where numbers do not yet exist (where run_speed_test would be the right sibling).

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds real value beyond them by disclosing that prices are live-checked against an external site, which signals freshness guarantees and possible latency/cost of the call.

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, zero filler, and the usage trigger is front-loaded before the content description. Every clause carries information (trigger, content, currency, freshness).

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 parameters, a rich annotation set, and an output schema already describing the return shape, the description only needs to supply the trigger and scope — both are present. An agent has everything required to decide to call it and to interpret 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 tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a no-arg tool applies. The schema is empty and fully covered, and no parameter guidance is missing.

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?

States a specific verb and resource (list the published plan catalog) plus the notable scope detail that prices are USD and live-checked against esimgomobile.com. It is clearly distinct from recommend_plan/compare_plans/get_plan_details in spirit, but it never names a sibling, so the differentiation is implied rather than explicit.

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?

"Use when the user asks what esimgomobile plans exist or what an eSIM costs" gives an explicit trigger condition, which is exactly what an agent needs for routing. It stops short of stating when NOT to use it or pointing to search_plans/recommend_plan for filtered or personalized queries.

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

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

Annotations already declare the full safety profile (readOnlyHint, idempotentHint, destructiveHint=false, openWorldHint=false), so the agent knows this is a safe, repeatable, local reference read. The description adds only provenance ('eSIM Go /networks parity endpoint, built-in reference'), which lightly reinforces openWorldHint=false, but offers no rate-limit, auth, or freshness context. With annotations carrying the burden, a 3 is appropriate.

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 sentence, front-loaded with the triggering condition, so the agent gets the key selection cue first. The trailing clause about the '/networks parity endpoint' is developer-oriented jargon that contributes little to selection or invocation, slightly diluting the sentence.

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 low-complexity, read-only, one-parameter lookup with a rich annotation set and an output schema, the description covers enough for correct invocation. The remaining gap is boundary-setting against heavily overlapping siblings, which is not addressed.

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

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

The single 'country' parameter is fully documented in the schema (100% coverage, with an example 'Japan'). The description adds no format guidance beyond that, so the schema does the heavy lifting and 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?

States a concrete verb+resource ('which mobile networks operate in a country') that maps directly to the name list_country_networks. However, it then broadens the scope to 'eSIM support / Wi-Fi / internet-freedom facts,' which overlaps with siblings like check_internet_freedom, find_free_wifi, and get_country_fact_sheet without explaining how this tool differs from them.

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?

Gives an explicit trigger ('Use when the user asks which mobile networks operate in a country'), which is clear context for invocation. It stops short of naming when-not to use it or pointing to the overlapping siblings (check_internet_freedom, find_free_wifi), so an agent must still guess at the boundary.

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 read-only, idempotent, non-destructive and closed-world, so safety is covered. The description adds real behavioral value beyond that: it is a static built-in table lookup, not a live carrier query, and most travel eSIMs auto-configure, which sets agent expectations about empty/limited results.

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 use condition, and the caveat sentence earns its place by preventing unnecessary calls. 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?

An output schema exists, so return values need no explanation, and a single fully-documented parameter keeps the surface small. It could add what to do when a carrier is absent from the table, but the definition is adequate for a simple static lookup.

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

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

Only one parameter, and the schema has 100% description coverage including richer examples (T-Mobile, UK, EU roaming) than the description's bare mention of 'a carrier'. Baseline 3 applies since the schema already carries the parameter meaning.

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?

States a specific verb (looks up) and resource (APN settings for a carrier) plus the underlying mechanism ('built-in APN table'), which distinguishes it from live/network tools like find_best_network or check_roaming_status. It does not explicitly name a sibling, so it stops short of 5.

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

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

'Use when the user needs APN settings for a carrier after installing an eSIM' gives a clear trigger condition, and the note that most travel eSIMs configure automatically implicitly tells the agent when this may be unnecessary. No explicit alternative (e.g. troubleshoot_esim) is named, so it is not a 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety and locality profile is covered. The description's one added signal is that results come from a built-in table, which corroborates openWorldHint=false, but it offers no further behavioral context. With annotations carrying the burden, a 3 is appropriate.

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

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

Two short sentences, with the usage trigger front-loaded and the implementation mechanism second. Nothing is redundant or padded.

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

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

An output schema exists so return values need no explanation, annotations cover the safety profile, and the sole parameter is fully documented. Nothing an agent needs in order to call this tool correctly 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 description coverage is 100% for the single required activity parameter, and the examples in the description (4K streaming, video calls, gaming) largely duplicate the schema's own example string. Baseline 3 applies since the schema does the heavy lifting and the description adds no new syntax or format guidance.

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: it looks up reference bandwidth requirements for a named activity from a built-in table. That static-table mechanism inherently separates it from siblings like run_speed_test (a live measurement) or calculate_data_budget (a computation), though it never names or contrasts those siblings explicitly.

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?

"Use when the user asks how much bandwidth an activity needs" gives clear trigger context, reinforced by concrete examples (video calls, 4K streaming, gaming). It stops short of stating when NOT to use it or pointing to alternatives such as run_speed_test for real measured speeds.

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

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

Annotations already declare readOnly/openWorld/idempotent/non-destructive, so the safety profile is covered. The description adds genuinely useful behavioral context the annotations don't: the probe is a real external HTTPS HEAD request issued from the deployment edge, and the returned metric is time-to-first-byte in milliseconds. It stops short of disclosing failure/timeout behavior or rate limits.

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

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

Two tightly written sentences with zero filler: the trigger condition is front-loaded, followed by the mechanism and unit of measurement. Nothing redundant or misplaced.

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 probe with an output schema present, the description supplies everything needed: when to call it, what request is actually made, and what the reported metric means. Return-value formatting is appropriately left to the output schema.

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

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

Schema description coverage is 100% and the single 'destination' parameter is fully documented in the schema, including the hostname-or-IP example. The description only echoes 'host' at a high level and adds no format or constraint detail beyond the schema. Baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific verb+resource (measure network latency to a host) and goes further by naming the exact mechanism: a real HTTPS HEAD request from the deployment edge measuring round-trip time to first byte in milliseconds. This clearly separates it from siblings like run_speed_test or grade_connection_quality, which measure throughput/quality rather than one-way RTT to a host.

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 opening 'Use when the user wants the network latency to a host' gives an explicit trigger condition, which is better than most siblings. However, it does not contrast itself with run_speed_test, check_coverage, or grade_connection_quality, so the agent must infer which latency-adjacent tool applies. Clear context, but no exclusions or alternatives named.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so the safety profile is covered. The description adds no behavioral detail beyond purpose — nothing about how the recommendation is derived or any caveats. Adequate but adds little beyond the structured hints.

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 tight sentences with the trigger condition front-loaded and zero filler. Every clause earns its place.

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

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

An output schema exists, so return values need not be explained, and one required parameter is fully documented in the schema. What remains thin is how the recommendation is produced or what differentiates it from compare_plans/recommend_plan, but nothing needed to invoke it correctly 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 description coverage is 100% for the single 'countries' parameter ('Countries on the itinerary'), so the schema carries the parameter semantics. The description only alludes to 'the country list' without adding format or granularity guidance, matching 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?

States a specific verb (recommends) and resource (single-country vs regional vs global plan types) scoped to multi-country itineraries. The multi-country qualifier implicitly separates it from recommend_plan and list_available_plans, but no sibling is named explicitly.

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 opening clause 'Use when the user has a multi-country itinerary and asks which eSIM plan type fits' gives a clear triggering condition. It stops short of naming the alternative to use for single-country itineraries or stating exclusions, so it is context-rich but not fully routing.

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, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds that this is a composite operation over the live catalog and built-in country references, which is useful behavioral context beyond the annotations, though it does not add authentication or rate-limit details.

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

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

The description is two tight sentences. It front-loads the usage condition and then efficiently specifies the composite output and data sources, with no redundant or filler content.

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

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

Given the rich annotations, full schema coverage, and an output schema, the description supplies everything an agent needs: when to call it, that it is a composite read-only operation, and what the single-call answer includes. Return-value details are appropriately deferred to the output schema.

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

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

Schema description coverage is 100%, so the schema already documents countries, days, and usage_profile. The description restates the itinerary inputs as countries + days + usage but adds no syntax, ordering, or enum guidance beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description states a specific composite purpose: it produces an estimated data need, a best plan pick with an alternative, and a per-country networks/eSIM/freedom brief in one call. It distinguished itself from sibling tools such as recommend_plan and calculate_data_budget by explicitly framing itself as a composite over the live catalog and built-in country references.

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 gives a clear condition for use: when the user provides an itinerary of countries, days, and usage, and wants the full answer in one call. It implies that single-purpose sibling tools are the alternative when only one component is needed, but it does not name those 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?

Annotations already declare this a safe, idempotent, closed-world read, so the bar is lower. The description adds meaningful behavior beyond that: it estimates GB before selecting, optimizes on cheapest, and sources prices from the 'real published catalog' – useful disclosure of how the pick is derived.

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 with the usage trigger front-loaded and the mechanism second; nothing is redundant. The first sentence is slightly packed with three conditions but still scannable.

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

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

For a read-only recommender with an output schema, the description covers what an agent needs: the trigger, the inputs it will use, and the nature of the result (a concrete cheapest plan with real prices). Return-value detail is correctly delegated to the output schema.

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

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

Schema description coverage is 100%, so all three parameters are already documented, and the description largely restates them ('where they're going, for how long, how much they'll use data'). It hints that usage_profile is converted into a GB estimate, but adds no formats, ranges, or multi-country handling detail 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 states a specific verb and resource ('picks the cheapest matching plan') and adds the internal step of estimating GB need, which separates it from lookup tools like list_available_plans or get_plan_details. It does not name a sibling directly, so the differentiation is implicit rather than explicit.

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 gives a concrete trigger ('Use when the user says where they're going, for how long, and roughly how much they'll use data, and wants a concrete plan pick'). That is clear context, but it offers no explicit when-not clauses or pointers to alternatives such as compare_plans or estimate_data_usage.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered by structured data. The description adds genuine value beyond that: it discloses that the tool runs a real download/ping measurement inside the interactive widget, warning the agent that this is an actual network action needing a UI context rather than a pure data lookup.

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 usage trigger followed by the mechanics and output. Every clause earns its place and there is no repetition of the tool name or title.

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

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

With an output schema present, the description need not explain return values, yet it still sketches them briefly, and no parameters exist to document. The only meaningful gap is that it does not help the agent choose between this and near-neighbour tools such as measure_latency or grade_connection_quality.

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 takes zero parameters, so there is nothing for the description to disambiguate and the baseline is 4. The description correctly spends no space on 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 states a specific verb+resource ('measure their current internet speed') and names the concrete outputs (Mbps, ping, quality grade), so the agent knows exactly what the tool produces. It does not, however, distinguish itself from closely related siblings like measure_latency or grade_connection_quality, which overlap in subject matter.

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 an explicit trigger condition ('Use when the user wants to measure their current internet speed'), which is a clear when-to-use statement. There are no exclusions or routing hints, though, and with 36 siblings including measure_latency and grade_connection_quality, the agent gets no guidance on which of these overlapping tools to prefer.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, open world), so the bar is lower. The description adds genuinely new behavior: it reads the live published catalog with a labeled snapshot fallback, which tells the agent about data freshness and possible staleness not encoded anywhere else.

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 trigger condition and no filler. The trailing parenthetical about snapshot fallback is terse but earns its place; nothing is redundant or bloated.

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

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

With an output schema present and annotations covering safety, the description only needs to supply trigger, scope, and any non-structured behavior — it does all three. The remaining gap is routing relative to sibling plan-discovery tools, which is left entirely implicit.

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 three enums fully documented, so the schema already carries parameter meaning. The description mirrors the filter set (type, max price, min GB, coverage scope, per-GB) without adding syntax, defaults, or edge-case notes beyond the schema (e.g. that fair-use plans always match min_gb). Baseline 3 applies.

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

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

States a specific verb+resource (browse/filter esimgomobile plans) and enumerates the filter dimensions it supports, so the agent knows exactly what the tool returns. It does not, however, distinguish itself from close siblings like list_available_plans, compare_plans, or recommend_plan.

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?

Opens with an explicit trigger phrase ('Use when the user wants to browse or filter...'), which is clear usage context. It gives no exclusions or sibling alternatives, so an agent must still guess whether compare_plans or list_available_plans is the better call for a similar request.

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 read-only, idempotent, non-destructive, and closed-world behavior. The description adds useful context about the guidance returned: OS-specific steps for low-data mode, background limits, offline maps, and downloads. It does not contradict the annotations.

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

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

Two sentences are front-loaded with the trigger condition and then summarize the returned guidance. Every sentence earns its place with no wasted text.

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 one required enum parameter, an output schema, and explicit safety annotations, the description supplies the trigger and content scope an agent needs. No call-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% and the sole parameter is documented as 'Phone OS' with ios/android enum values. The description reinforces that the steps are OS-specific but adds no syntax or semantic detail beyond the schema, so the baseline 3 applies.

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

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

States a specific action and outcome: setup for data saving with OS-specific steps covering low-data mode, background limits, offline maps, and downloads. The travel-data-plan context distinguishes it from generic installation or checklist siblings.

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

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

Explicitly says when to use it: when the user wants to stretch a travel data plan. It does not name alternatives such as get_travel_data_checklist or setup_dual_sim, so it falls short of full alternative routing.

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 state this is a read-only, idempotent, non-destructive, closed-world helper, so the safety profile is covered. The description adds that the tool explains line assignment for data, calls, and iMessage and how to avoid roaming charges, but it does not disclose any additional behavioral traits such as whether it inspects the device or what form the guidance takes. A 3 is appropriate because it adds useful scope but no new behavioral caveats beyond 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 use case, and no filler. Every clause tells the agent when to use the tool and what it covers.

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?

Output schema exists and annotations cover safety, so return values and safety need not be described. The description states the user scenario and topics explained, making it complete enough for a simple informational helper. It stops short of routing to alternatives among the many sibling tools, so 4 rather than 5.

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 only parameter primary_use is fully described in the schema, so the schema carries parameter semantics. The description does not reference primary_use or add syntax/examples beyond the schema. Baseline 3 for high coverage with no additional param meaning.

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?

States a specific scenario and content: home line plus travel eSIM configuration, explaining which line handles data, calls, and iMessage, and roaming avoidance. It distinguishes from generic eSIM troubleshooting and plan tools by focusing on dual-SIM line assignment, though it does not name a sibling.

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 first sentence gives an explicit when-to-use condition: home line plus travel eSIM and needing the right configuration. It implies but does not state exclusions or name alternatives like troubleshoot_esim or get_installation_guide, so 4.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and openWorldHint=false, so the agent knows this is a safe, repeatable local diagnosis. The description adds the diagnostic framing and the bounded problem space but discloses nothing further about what the tool actually performs or returns. Adequate against the lower bar set by 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, zero filler, with the usage trigger front-loaded before the capability list. Every clause carries information.

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

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

An output schema exists, so return values need no explanation, and the input surface is a single well-documented enum. For a low-complexity, read-only diagnostic tool, the description supplies everything an agent needs to select and call it.

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

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

Schema description coverage is 100% and the single enum parameter's values are fully enumerated in the schema, so the baseline is 3. The prose symptom list loosely mirrors the enum members (no service, no data, slow data, QR issues, activation failures, calls not working) but adds no syntax, defaults, or selection guidance beyond 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?

States a specific verb (diagnoses) and resource (eSIM) and enumerates the concrete failure classes it handles (no service, no data, QR issues, activation failures, calls not working). This implicitly separates it from setup-oriented siblings like get_installation_guide or setup_dual_sim, but no sibling is named explicitly, so it falls short of full 5-level differentiation.

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

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

"Use when the user's eSIM isn't working" gives a clear activation condition, and the symptom list sharpens it into recognizable user-reported contexts. There are no explicit exclusions or named alternatives for edge cases (e.g., where to go if the problem is coverage rather than the eSIM itself), which keeps it at 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?

Annotations already declare readOnly, idempotent, and non-destructive, and the description reinforces that with "Places no order and charges nothing" plus the fact that a price estimate is returned. It adds a genuinely new behavioral constraint not present in the schema: only single-country scope is validated against the itinerary.

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 ordered as trigger, checks performed, and side-effect guarantees. Every clause carries information an agent needs, and the most decision-relevant content (when to use, no charge) is front- and back-loaded for scanning.

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?

Output schema covers the price estimate, annotations cover the safety profile, and the schema fully documents all four parameters. The description fills the remaining gap by explaining the validation rules and the no-charge guarantee, leaving nothing an agent needs before calling.

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, but the description goes further by explaining what each parameter is used for in the check: quantity validated within 1-50, device_model drives a compatibility check, and countries is specifically for scope validation rather than, say, pricing.

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?

States a specific verb (verify/validate) and enumerates exactly what is checked: plan id existence, quantity bounds, eSIM compatibility, and country scope, then that it returns a price estimate. It also positions itself as the pre-purchase dry run, which separates it from siblings like compare_plans and get_plan_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?

"Use when the user is about to buy and wants everything checked first" gives a clear activation condition tied to purchase intent. It does not explicitly name an alternative or an exclusion (e.g., when to skip validation and go straight to ordering), which keeps it 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.