TidyData Tools

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds real behavioral context — weekends and public holidays of 100+ countries are skipped — but then advertises 'Custom weekend days' even though no parameter in the schema supports customizing weekends, which is misleading rather than clarifying.

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 opening two sentences are near-duplicates ('Add business days to a date.' / 'Add business days.'), and the third sentence crams in a second, competing capability. A third of the text is redundant and the rest is not front-loaded around the actual add/subtract use case.

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 3-parameter, read-only calculation tool with no output schema, the description covers the key domain concept (holiday-aware business days). However, it never states the return format or how the country parameter affects the result, and its count-between-dates claim makes the tool's actual contract ambiguous.

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 date, days, and country are already documented with format examples, establishing a baseline of 3. The description's holiday-skipping note gives useful context for what 'business day' means here, but its 'custom weekend days' claim maps to no parameter and adds confusion instead of 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 first sentence names a verb and resource ('Add business days to a date'), but the second sentence repeats it verbatim and the third claims 'Count working days between two dates' — which is the job of the sibling tool business_days_between. The definition therefore blurs its own scope with a sibling rather than distinguishing itself, leaving the agent unsure whether this tool counts or adds.

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

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

There is no statement of when to use this tool versus business_days_between, is_public_holiday, or public_holidays, all of which touch the same domain. The only implicit signal is that the tool adds/subtracts, but the description undercuts even that by also claiming the counting use case.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds useful context — a static dataset of ~9,500 airports with coordinates, elevation, country, region and city, and that the output includes flight time in addition to distance — but says nothing about units, formatting, or behavior on invalid codes.

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

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

The first two sentences say the same thing twice, and the rest is a feature dump mixing in capabilities from other tools rather than front-loading what this tool computes. Content that matters (great-circle distance, flight time) is buried mid-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?

With no output schema, the description carries the return-value burden — it does state it returns distance and flight time, but omits units, precision, and error behavior. The dataset attributes are filler for a caller who only needs from/to. Adequate but with clear gaps.

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

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

Schema description coverage is 100% and the two required parameters (from/to) are documented as IATA/ICAO codes with examples, so the schema does the work. The description only echoes 'IATA or ICAO code' without adding format, fallback, or ambiguity-resolution 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 does eventually name a specific computation ('great-circle distance and flight time between two airports'), but it opens with a tautological restatement of the title and then lists capabilities that belong to siblings (airport lookup by IATA/ICAO, search by name or city, nearest airports). It never distinguishes itself from airport_info, airport_search, or distance_between_places, so an agent could easily mis-route.

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

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

There is no when-to-use guidance and no exclusions. The listed 'lookup/search/nearest' capabilities actively suggest the tool covers jobs handled by airport_info and airport_search, with no statement of which one to pick.

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, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds useful data-scope context (9,500 airports, includes coordinates, elevation, country, region, city), but it also implies behaviors the single 'code' parameter cannot support. No output schema exists, yet the description gives only a partial picture of what is returned.

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 opening is a near-verbatim triple restatement ('Airport by IATA/ICAO code. Airport by code. Airport lookup by IATA or ICAO code...'), which is pure padding. The front-loaded clause is fine, but the redundancy and feature-list sprawl waste the reader's attention.

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 lookup tool this should be simple, but the description advertises search-by-name, nearest-airport and distance/flight-time features that the schema cannot deliver with only a 'code' argument. With no output schema, the description should clarify return shape; instead it leaves the agent with an inflated and partly unachievable capability picture.

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 sole 'code' parameter is fully documented with IATA/ICAO examples, so the schema carries the burden; baseline 3 applies. The description adds no syntax or format detail beyond the schema, and its claims about name/city search and coordinates are not backed by any parameter.

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

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

The core purpose is stated ('Airport by IATA/ICAO code'), which is a specific verb+resource. However, the description then bolts on capabilities that belong to siblings ('search by name or city', 'nearest airports to any coordinates', 'distance and flight time between two airports'), muddying what this tool actually does versus airport_search and airport_distance. The result is a vague, over-broad purpose rather than a crisp one.

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

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

There is no when-to-use guidance and no mention of the obvious alternatives among siblings (airport_search, airport_distance, distance_between_places). By claiming to also do search-by-name and airport-to-airport distance, it actively competes with those siblings without telling the agent which to pick.

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, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description does add genuinely useful context beyond the annotations – dataset size (9,500 airports) and the fields returned (coordinates, elevation, country, region, city) – but says nothing about result ordering, pagination or how the limit interacts with total matches.

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 opens with the title, immediately restates it ('Search airports.'), then pads with a run-on sentence listing features that are not parameters of this tool. Sentences do not earn their place; the core purpose is buried in keyword-style enumeration.

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

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

With no output schema, the description partially compensates by naming returned fields (coordinates, elevation, country, region, city), which is helpful. But it omits result format, ordering and limit/pagination behavior, and its inflated scope claim is a completeness liability rather than an asset.

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 q, limit and country are already documented in the schema, making 3 the baseline. The description's mention of IATA/ICAO code and name/city lookup loosely maps to q, but adds no syntax guidance for country (ISO code format) or limit range beyond what the schema states.

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 opening sentences correctly state a verb+resource ('Search airports by name or city'), and the third sentence accurately notes that lookup works by IATA/ICAO code as well as name or city. However, the description then claims capabilities (nearest airports to coordinates, great-circle distance and flight time between two airports) that belong to sibling tools like airport_distance, muddling rather than sharpening its scope.

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

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

There is no statement of when to use this tool versus airport_info, airport_distance or city_search. Worse, by advertising distance/flight-time computation it implies this tool should be picked for queries that a sibling likely owns, which is actively unhelpful for 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, openWorldHint and destructiveHint=false, so the safety profile is covered. The description does add real context by disclosing that weekends and public holidays for 100+ countries/regions are skipped and that custom weekend days are supported, but says nothing about return shape or how the holiday database is selected.

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

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

The first two sentences are redundant restatements of the tool name/title, consuming prime front-loaded space without adding information. The useful content (holiday coverage, custom weekends) only appears in the trailing 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 five-parameter, read-only, no-output-schema tool, the description covers the key domain behavior (weekend/holiday skipping, 100+ country coverage, custom weekends). It is reasonably complete; the main omission is any statement of what the call returns or how the count relates to the add/subtract sibling.

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 five parameters (start, end, country, state, weekend) are already documented in the schema. The description only echoes 'custom weekend days' and country coverage, adding no syntax or format detail beyond the schema, so baseline 3 applies.

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

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

The core verb+resource ('count working days between two dates') is clear, but the description opens with two near-identical restatements of the title and then adds 'and add/subtract business days,' which blurs its purpose with the sibling add_business_days. An agent gets the gist but the scope statement undercuts itself.

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

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

There is no when-to-use guidance and no mention of the obvious alternatives (add_business_days, is_public_holiday, public_holidays) that appear in the sibling list. The claim that it can 'add/subtract business days' actively muddles routing rather than clarifying it.

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

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

Annotations already declare readOnly/openWorld/non-destructive, but the description adds real behavioral context: it lists the redirect codes followed (301/302/307/308), notes loop detection, describes returned fields (final URL, server, response time), and gives a batch limit. That is meaningful disclosure 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?

Front-loaded and short, but the telegraphic fragments repeat the same idea ('HTTP status and redirect chain of a URL... Check URL. HTTP status...') without earning their place. Functional, but not tight or well-structured.

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

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

With no output schema, the description carries the return-value burden and does so by naming status, redirect chain, final URL, server, and response time. It is nearly complete for a single-param read tool; only the batch-vs-single-URL ambiguity leaves a small gap.

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

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

Schema coverage is 100%, so the schema already documents url and maxRedirects, making 3 the baseline. The description adds a batching note ('up to 20 URLs per call') that is not reflected in the single-`url` schema, which is mildly confusing rather than clarifying.

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 (check a URL's HTTP status and redirect chain) and enumerates what it returns. It is distinguishable from link_preview or expand_short_url in intent, but it never explicitly contrasts itself with 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?

'Find broken links fast' implies a use case, and 'POST up to 20 URLs per call' hints at batch sweeps. However, there is no explicit when-to-use/when-not guidance and no named alternative, so usage is only implied.

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

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

Annotations already declare readOnly/openWorld/non-destructive, so the bar is lower, and the description still adds useful context: scale of coverage (171,000 places) and the fact that there is no rate-limited upstream. It also discloses the returned fields. It does not contradict any annotation.

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

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

Front-loaded but redundant: the parenthetical restates the title, and 'Search places by name' repeats the opening sentence. The capability list is packed into one long clause, and the parenthetical output list is repeated again later.

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?

It lists returned fields, which partly compensates for the missing output schema, but it claims reverse geocoding even though the only required parameter is a name query (q), so an agent cannot tell how coordinates-in would be supplied. No pagination or response-shape detail.

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 q, limit and country; the description adds no syntax, format, or defaults beyond it. 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?

States a specific verb+resource (find/search a city) and enumerates what comes back (coordinates, population, country, time zone). However, it bundles in reverse geocoding and nearby-radius search, overlapping the reverse_geocode and distance_between_places siblings without naming or differentiating them, which muddies the tool's actual scope.

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

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

There is no when-to-use / when-not-to-use guidance and no named alternative. The agent is not told to prefer reverse_geocode for coordinate lookups or distance_between_places for radii, even though the description claims those capabilities.

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, and destructiveHint=false, so safety is covered. The description adds genuinely useful behavioral context beyond that: the exact set of 13 supported calendars and the operational 1900-2100 year boundary, which is a real constraint an agent must respect.

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, but the first duplicates the title verbatim and the fragment 'Gregorian date in all calendars' is ambiguous and low-value. The new information (calendar list, 1900-2100 range) is buried at the end rather than 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 no output schema, the description carries the burden of explaining what comes back, yet it never describes the return shape – whether all 13 calendars are returned or only the requested ones, or how the holiday results are structured. It is adequate on inputs and scope but incomplete on outputs for a two-optional-parameter conversion tool.

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

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

Schema description coverage is 100% – both parameters (date default today, calendars comma list) are fully documented in the schema. The description's enumeration of calendar ids loosely parallels the calendars parameter but adds no syntax, delimiter, or default guidance beyond what the schema already provides, 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 verb (convert) and resource (calendar date) and enumerates the target calendar systems, which clearly separates it from siblings like convert_time_zone or convert_units. An agent can identify this tool 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?

The description implies its use cases (date conversion across 13 calendars, plus holiday dates for Islamic/Jewish/Chinese/Persian) and implicitly scopes them to 1900-2100. However, it never states when to prefer it over alternatives such as public_holidays or is_public_holiday, nor any exclusions, so usage is only implied rather than directed.

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 (readOnlyHint, non-destructive, openWorld), so the description earns credit for adding real context: ECB as the source, daily reference-rate cadence, the 30+ currency coverage, arbitrary base currency, and a 90-day history window. It does not disclose what happens for unsupported currencies or unsupported dates, keeping it short of a 5.

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?

It opens with the title text restated and then a fragment ("Convert amount."), which is redundant padding, while the genuinely informative facts (rate source, cadence, history window) are buried in the trailing fragment. It is short but not well front-loaded or edited.

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

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

With no output schema, the description must carry the interaction burden, and it does cover source, currency coverage, and history window. It omits how a conversion result is presented and how the date parameter behaves relative to the 90-day window, which leaves gaps for a calculation tool whose result shape matters.

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 four parameters are already documented in the schema and the baseline is 3. The description adds mild meaning ("any base currency", "history of the last 90 days" implying the date parameter selects historical lookups) but no format or constraint detail beyond that.

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 verb and resource ("Convert amount" with ECB reference rates) and scopes it with "30+ currencies, any base currency". It is clear what the tool does, but it never distinguishes itself from the sibling tool exchange_rates, leaving the agent to guess which one to pick for raw rates vs. conversion.

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

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

There is no explicit when-to-use guidance and no named alternative, despite exchange_rates being an obvious overlapping sibling. Usage is only implied by the word "Convert", so an agent has no stated rule for choosing between this tool and exchange_rates.

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, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds genuine behavioral detail beyond that: it accepts 'now' or an arbitrary date and returns UTC offset, weekday and Unix time, plus batch fan-out to many zones. It says nothing about invalid-zone handling or rate limits, so it is useful 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?

The opening sentence restates the title verbatim and the fragment 'Time in zones.' carries no information, so roughly the first half is waste. The remaining sentence is dense and informative but is not front-loaded as the lead.

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

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

With no output schema, the description partially compensates by naming the return fields (offset, weekday, Unix time), which is the key thing an agent needs. All three optional parameters are schema-documented, so little is missing for a tool of this complexity.

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

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

Schema description coverage is 100%, so the schema already documents tz, to and datetime fully, and the baseline is 3. The description only implies the batch fan-out ('many time zones at once') and the empty-equals-now default, both of which the schema text already carries.

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 (convert a moment across IANA time zones) and the outputs produced (UTC offset, weekday, Unix time), which is concrete enough to distinguish it from sibling lookups like timezone_by_coordinates or sunrise_sunset. It never names a sibling explicitly, so an agent must infer the boundary itself.

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

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

The description implies its use case (current time or any date, one-to-many conversion) but gives no explicit when-to-use, when-not, or alternative tooling. An agent choosing between this and timezone_by_coordinates or convert_calendar_date gets no routing help.

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, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds real capability context beyond that: the breadth of unit categories supported and the fact that arbitrary math expressions, constants, and matrices can be evaluated safely rather than just scalar conversions.

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 opening 'Convert units of measure. Convert units.' repeats the title and name with zero added information, which is wasted space. The remaining sentence is dense and informative, but the duplication weakens the front-loading.

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

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

There is no output schema, so the description should ideally indicate the return shape (e.g., converted value with unit) and behavior on invalid or mismatched units. It covers input scope well but leaves the return value and failure behavior unstated for a tool whose whole job is producing a converted 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?

Schema coverage is 100%, so each parameter is already documented in the schema, and the baseline is 3. The description hints that the 'value' parameter accepts expressions, but never states this mapping explicitly, so it adds little semantic value beyond the schema.

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

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

States a specific verb+resource (converting units of measure) and enumerates categories and capabilities (300+ units, expression evaluation with functions/constants/matrices). However it does not distinguish itself from close siblings such as convert_currency, convert_calendar_date, or convert_time_zone, leaving ambiguity about scope boundaries.

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

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

Usage is implied by the tool's nature, but there is no explicit when-to-use guidance and no named alternative. In particular, an agent cannot tell from the description whether currency conversion belongs here or in convert_currency, which is a meaningful routing gap given the sibling list.

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, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description usefully enumerates what is returned (native name, capital, continent, calling codes, currencies, languages, emoji flag) in the absence of an output schema, but it also advertises filter capabilities that the schema does not support, which undercuts trust.

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 with the first duplicating the title and the third a long comma-separated field list. The 'Country by code' sentence is front-loaded and useful, but the opening is wasted space and the field enumeration is dense and unstructured.

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

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

For a tool with no output schema, describing the returned fields is the right instinct and largely done. The gap is that the advertised filter surface does not match the two-parameter schema, leaving the agent with an inaccurate picture of how to actually constrain results.

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

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

Schema description coverage is 100% for both parameters (code, lang), so the baseline would be 3. However, the description promises filtering by continent, currency, language and search, none of which exist as parameters in the schema, giving the agent a misleading impression of the callable interface that could lead to failed invocations.

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

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

The description states the resource (country data) and the lookup key ('Country by code'), and enumerates the fields returned, so an agent can tell it is a country lookup rather than, say, a city or geocoding tool. It loses a point for opening with a verbatim restatement of the title, which adds no distinguishing information.

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

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

There is no statement of when to use this tool versus alternatives such as city_search, reverse_geocode or airport_info, and no exclusions or prerequisites. 'Filter by continent, currency, language or search' hints at modes but gives no selection logic between them.

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, destructiveHint=false and openWorldHint=true, so safety and external-dependency context is covered. The description adds a genuine behavioral trait beyond that – 'Always answers, even when the upstream registry is slow' – signaling latency/fallback behavior. It does not cover rate limits, error cases, or output format.

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

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

The opening is padded with redundancy: 'Decode a vehicle VIN. Decode VIN.' says the same thing twice before any new information. The remainder is a dense, useful field list, but the front-loaded duplication costs efficiency.

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

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

With no output schema, the description carries the return-value burden and does so well by enumerating decoded fields plus check-digit validation and origin data. It is complete for a one-parameter lookup tool, missing only edge-case behavior (invalid VIN handling).

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 'vin' parameter is fully documented in the schema with an example. The description repeats the 17-character constraint but adds no syntax or format detail beyond what is already structured. 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 ('Decode') and resource ('vehicle VIN'), then enumerates the exact fields returned (make, model, model year, trim, body, engine, fuel, transmission, drive type, plant). No sibling tool overlaps with VIN decoding, so no disambiguation is needed. An agent can confidently tell what this does.

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

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

Usage is only implied by the tool's single purpose – there is no explicit 'use when' or 'do not use when', though with only one VIN-related sibling absent from the list, there is little to route between. The 17-character constraint hints at applicability but is not framed as 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?

The description contradicts the openWorldHint=true annotation by claiming 'works offline', which implies no external-world interaction. Although it adds useful return-field and performance context, the contradiction forces a score of 1 under the rule.

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

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

The first two sentences ('Language of a text. Detect language.') are redundant with the title and name, while the third and fourth sentences carry all the useful information. The content is short but not optimally front-loaded because of the repeated framing.

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

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

For a simple one-parameter tool with no output schema, the description does well by listing return values and noting performance characteristics. It omits input length limits or handling of ambiguous text, but it is otherwise sufficient for correct invocation.

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

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

Schema description coverage is 100%, so the single 'text' parameter is already fully documented. The description adds no additional parameter syntax, constraints, or examples beyond what the schema provides; baseline 3 is appropriate.

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

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

The description names a specific verb and resource ('Detect the language of any text') and lists concrete output fields (ISO 639-3 code, English name, confidence, reliability flag, top 5 candidates). No sibling tool competes for language detection, so it is immediately distinguishable from the unrelated utilities.

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

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

The description gives no explicit when-to-use or when-not-to-use guidance. It states the tool works on 'any text' but does not name alternatives, prerequisites, or exclusions. This is comparable to a minimal definition with no routing advice.

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, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds genuinely useful context: the 147,000-word corpus size and automatic inflection resolution. It does not say what happens on a miss (unknown word, error vs empty result), so it is solid 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?

The first two sentences overlap ('English definitions of a word. Word definitions.'), with the second carrying no information. The third is a dense but load-bearing feature list, so the text is front-loaded but contains one wasted 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?

With no output schema, the description must carry return-value burden, and it largely does: definitions partitioned by part of speech, usage examples, synonyms/antonyms, broader terms, IPA/ARPAbet, syllable count, rhymes and prefix autocomplete. Missing only error/empty-result behavior for words outside the corpus.

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 word, pos and limit are already documented in the schema; baseline 3 applies. The phrase 'definitions by part of speech' loosely hints at the pos filter but adds no format, default, or interaction 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?

States a specific verb+resource ('English definitions of a word') and enumerates the exact payload the agent gets back, so the function is unmistakable. However, the second sentence 'Word definitions' is pure tautology, and the description never acknowledges the sibling tools rhymes and synonyms even though it claims to return those same data types, leaving routing ambiguity.

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

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

No when-to-use guidance and no exclusions are given. The only contextual note is that inflected forms (running, cities) resolve automatically, which is useful but is a capability statement, not usage direction. An agent has no help deciding between this, rhymes, synonyms, or spell_check.

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 safety, but the description adds real value by disclosing the computation method (Vincenty ellipsoidal) and the rich result set: km/miles/nautical miles, bearing, compass, midpoint, flight time, and distance matrices. This tells the agent what it gets back beyond the safety profile.

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

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

The first two sentences redundantly restate the title/name ('Distance between two places or coordinates. Distance between two places.'), wasting prime front-loaded space. The later sentences do carry useful content, but the definition is 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?

With no output schema, the description responsibly enumerates the return fields and input formats, which is what an agent needs to call and interpret the tool. It stops short of any usage routing against sibling tools, which is the main remaining gap.

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

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

Schema description coverage is 100% and both parameters are documented with examples (coordinates, city, airport code). The description restates the accepted formats but adds no syntax or constraint detail beyond what the schema already provides, so baseline 3 applies.

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

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

The description names a specific computation (distance) between two named inputs and enumerates accepted input formats. However, it never distinguishes itself from the close sibling airport_distance, so an agent cannot tell which one to pick without opening both.

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

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

There is no when-to-use or when-not-to-use guidance and no alternative tool is named, despite airport_distance being an obvious overlapping sibling. The only implied guidance is the general capability itself.

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/destructiveHint, so the safety profile is covered. The description adds genuine context beyond them: public resolvers (implying cached/non-authoritative results) and derived outputs like mail-server presence and SPF. It says nothing about rate limits, caching, or output shape.

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 opening 'DNS records of a domain. DNS records.' is pure repetition of the tool name and title and burns the most prominent position. The remainder is dense and useful, but the front-loading is wasted.

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 two-parameter read-only lookup with no output schema, the description tells the agent what it returns (record set plus mail-server/SPF signals) and how it resolves. Sufficient, though it could note result caching/authoritative differences.

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, making 3 the baseline. The description's type list (A, AAAA, MX, NS, TXT, CNAME, SOA, CAA, SRV) is slightly richer than the schema's example for `types`, but adds no format guidance beyond what the schema gives.

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 ("Look up DNS records of any domain") and enumerates the record types it returns, so the agent knows exactly what it gets. It does not differentiate itself from the very close sibling dns_propagation (or domain_whois), which is the main gap.

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?

"in one call" implies a batching benefit but there is no explicit when-to-use, no when-not-to-use, and no alternative named. With dns_propagation and domain_whois in the sibling list, the absence of any routing guidance is a real 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 read-only, non-destructive, open-world behavior, so the bar is lower. The description adds useful context beyond that: the exact six resolvers queried and the fact that results include agreement, a consensus answer, and response times, which tells the agent what a multi-resolver fan-out returns.

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

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

The first clause establishes the scope and the last sentence carries the real payload, so it is front-loaded. But 'Check propagation.' duplicates the first sentence and the opening of the third, a wasted sentence that should have been cut.

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

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

With no output schema, the description does part of the return-value work by naming agreement, consensus answer, and response times. Combined with annotations covering safety and 100% schema coverage, it is nearly complete, though resolver list, no auth/rate-limit notes, and return shape details keep it short of 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 description coverage is 100% with only two parameters (domain, type), so the schema already carries the parameter meaning. The description adds no format or constraint detail beyond it — baseline 3 is appropriate.

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

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

The description states a specific verb and resource — checking whether a DNS change has propagated by querying six named resolvers at once. That scope implicitly separates it from the sibling dns_lookup, but no sibling is named, so the differentiation is inferred 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 one implied scenario ('Check if a DNS change has propagated'), which is a usable context. However it never states when to prefer this over dns_lookup or any other alternative, nor any exclusions or prerequisites, so guidance remains implied.

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

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

Annotations already cover the safety profile (readOnlyHint, destructiveHint=false, openWorldHint), so the bar is lower. The description adds genuine context beyond that: the official RDAP data source with DNS fallback, and that it returns creation/expiry dates and registrar info. It omits rate limits or auth needs, keeping it out of 5 territory.

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 opening 'Is a domain name available? Check availability' restates the title and is redundant, wasting the front-loaded position. The remaining sentences are dense and useful, but the tautological lead-in drags the structure down.

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

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

With no output schema, the description carries the burden of explaining returns, and it partially does so (creation/expiry dates, registrar, suggestions). Given the multiple input modes (name+tlds, domain, domains) it is reasonably complete, though the exact return shape remains only loosely sketched.

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 all five parameters fully, setting the baseline at 3. The description adds marginal meaning by echoing RDAP/DNS sourcing and the '.com suggestions' concept (the suggest param) but does not add syntax 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 (check domain name availability) and adds scope differentiation: bulk availability across many extensions using RDAP data. This is clear, but it never distinguishes itself from close siblings like domain_whois or dns_lookup, which touch the same underlying data.

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

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

There is no explicit when-to-use or when-not guidance and no named alternatives, despite the presence of highly similar siblings (domain_whois, dns_lookup). The 'across many extensions in one call' phrasing hints at bulk checking but falls short of routing the agent between tools.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is covered. The description adds genuinely new context beyond the annotations: the data comes from the official RDAP registry rather than scraped WHOIS, and it explicitly returns 'No personal contact data', which sets expectations about result contents and privacy.

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 front-loading is good, but the second sentence 'Domain info.' is pure redundancy after the title and first sentence, and the parenthetical '(WHOIS/RDAP)' is repeated from the title. The remaining content is dense and earns its place, but those wasted fragments drag the structure down.

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

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

With no output schema, the description usefully enumerates the returned fields (registrar, created, expiry, age, status, nameservers) and the data source, which is what an agent needs to know it is the right tool. It omits what happens for an unregistered or invalid domain (error vs. empty result), the one behavioral gap for a lookup tool.

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

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

There is a single parameter with 100% schema description coverage (type plus an example, 'apify.com'), so the schema already carries the semantics. The description adds no extra guidance on accepted formats (subdomains, IDN, trailing dots), 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?

It names a specific resource and enumerates exactly what it retrieves (registrar, creation date, expiry, age, status, nameservers) and the underlying data source (RDAP). However, the opening line 'Is a domain registered?' overlaps with the sibling domain_availability, and the description never draws that boundary, so an agent could pick the wrong tool for a pure availability check.

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 list of questions ('Who is the registrar, when was it created, when does it expire') implies the use case clearly enough to invoke it, but there is no explicit when-to-use versus domain_availability or dns_lookup, and no stated exclusions or prerequisites.

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, and destructiveHint=false, so the safety profile is covered without the description. The description adds the data source (ECB), currency breadth, and the 90-day lookback constraint, but the 90-day window is also stated in the date parameter schema, so the net new behavioral context is modest. No return format or rate-limit behavior is disclosed.

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 opening two sentences ('Latest exchange rates. Latest rates.') are a redundant restatement of the title and waste prime front-loaded space. The remaining sentence is dense and informative, but the description is not free of filler.

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

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

With no output schema and zero required parameters, the description carries the burden of scope-setting, and it does deliver source, coverage, base-currency flexibility, and the historical window. It stops short of explaining the response shape or resolving overlap with convert_currency, which is the main remaining hole.

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 schema description coverage at 100%, all three parameters (base, date, symbols) are already documented, including the EUR default and the 90-day date range. The description reinforces 'any base currency' but adds no format, syntax, or edge-case 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?

The description names the resource (ECB daily euro reference rates), the coverage (30+ currencies, any base), and the scope (conversion plus 90-day history), so an agent knows this is a rates/history lookup rather than a generic utility. However, it never distinguishes itself from the sibling convert_currency, leaving real ambiguity about which tool handles a conversion 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?

There is no when-to-use statement, no prerequisites, and no alternative named. Given the near-identical sibling convert_currency, the absence of routing guidance is a meaningful gap rather than a minor omission.

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, and destructiveHint=false, so the safety profile is covered. The description adds genuine behavioral value by disclosing that it follows 'every hop of the redirect chain' to the final destination, which tells the agent what output semantics to expect.

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 and appropriately short, but the opening three fragments ('Expand a shortened link. Expand short URL. Expand short links...') restate the same idea redundantly before reaching the informative content about redirect chains.

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

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

For a single-parameter read-only tool with no output schema, the description covers what it does, the range of inputs accepted, and the redirect-chain behavior. It could say more about the return shape (final URL plus hop list), but an agent has enough to invoke 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?

Only one parameter (url) with 100% schema description coverage, so the schema already documents it. The description's shortener examples add mild context but no syntax or format detail beyond the schema's own example. 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 (expand a shortened link) and goes further by naming example shorteners (bit.ly, t.co, tinyurl) and clarifying it handles 'any redirect'. This distinguishes it from siblings like link_preview or check_url_status, which an agent might otherwise confuse it with.

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 closing line 'Check where a link really goes before clicking it' implies the use case, but no sibling is named and there are no explicit when-not conditions (e.g., when to prefer check_url_status or link_preview). Usage is implied rather than specified.

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 and destructiveHint=false, so the safety profile is covered. The description adds output-shape context (rows, or objects keyed by headers, or CSV download), which is useful, but says nothing about failure modes such as pages with no tables or JS-rendered tables.

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

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

The first two fragments ('Tables of a web page as JSON. Extract tables.') restate the title and name redundantly before the one sentence that earns its place. The informative clause is not front-loaded, so there is noticeable 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?

With no output schema, the description must carry return-value information, and it partially does by naming JSON row/object and CSV outputs. However, for a 4-parameter tool it omits index behavior, empty-table handling, and any pagination or size limits.

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 all four parameters are already documented, giving a baseline of 3. The description adds a small amount of connective meaning by mapping 'rows or objects with headers' to the objects flag and 'CSV' to the format flag, but no syntax or default details beyond the schema.

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

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

The description states a specific verb (extract/turn into) and resource (HTML tables of a web page) and even names the output shapes (JSON rows/objects, or CSV). It is distinct from sibling extractors like extract_links and extract_keywords, though it never explicitly contrasts itself with 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?

There is no when-to-use guidance: nothing tells the agent when to prefer this over extract_links or extract_keywords, nor how to choose JSON vs CSV output. The only implied usage is 'for a page that has tables'.

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/destructiveHint=false, so the safety profile is covered; the description earns credit by adding method (RAKE algorithm with per-language stopwords), automatic language detection, and the fact that the result includes scores and counts. It does not disclose rate limits or output structure in detail, but it adds real behavioral context beyond the annotations.

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

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

The first two sentences ('Keywords of a text (58 languages). Extract keywords.') merely restate the title and name with no added information, so nearly half the text is filler before the one informative sentence about the algorithm and output. The real content is front-loaded only after the redundancy.

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

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

With no output schema, the description should characterize the return value; 'scores and counts' is a hint but not a clear picture of the response shape, so an agent must guess at the result format. Parameter and safety needs are otherwise covered, and the minor 58-vs-50+ languages inconsistency is a small blemish.

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 lang, text, limit, and max_words are already fully documented in the schema with ranges and defaults. The description's mention of auto language detection marginally reinforces the 'lang' parameter but adds no syntax or semantics beyond the schema, making the baseline 3 correct.

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 ('Extract keywords', 'key phrases and most frequent words') and names the mechanism (RAKE with language stopwords), which is enough to distinguish it from siblings like summarize or dictionary_define. It stops short of explicitly contrasting with those siblings, so it lands at 4 rather than 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 description says it works on 'any text in 50+ languages' but gives no when-to-use guidance, no prerequisites, and never names an alternative (e.g. summarize when you need prose rather than keyword lists). Usage is only inferable from the verb.

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, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds useful detail about the shape of the result (anchor text, rel, nofollow flag, classification), which goes beyond the annotations. It says nothing about auth needs, rate limits, or page-size limits, so it is a modest but real addition.

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 overlapping clauses restate the same idea: the title, then 'Extract links.', then 'Extract every link of a web page...'. The redundancy crowds out the one genuinely useful sentence, and 'Filter by type' is tacked on as an orphan fragment.

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

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

With no output schema, the description carries the return-value burden and does so by enumerating the emitted fields (anchor text, rel, nofollow, internal/external). Combined with annotations covering safety and a fully documented 2-parameter schema, an agent has enough to invoke it correctly, though filtering behavior remains thin.

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 url and type are already documented in the schema, and the description contributes only the notion that 'type' filters internal/external results. No format, default, or edge-case semantics are added 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?

Specific verb+resource: extracting every link from a page, with the exact fields returned (anchor text, rel, nofollow, internal/external). It is distinguishable from siblings like extract_html_tables or extract_keywords by naming the resource as links. However, it never contrasts itself with link_preview or sitemap_urls, which occupy adjacent territory.

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 only usage instruction is the fragment 'Filter by type,' which restates the optional parameter rather than saying when to choose internal vs external or when to prefer this tool over link_preview/sitemap_urls. No context, prerequisites, or exclusions are given.

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, destructiveHint=false, and openWorldHint=true, so the safety profile is covered without description help. The description contributes the useful behavioral claim that generation is cryptographically secure and can be done in bulk, which is real added context beyond the annotations. It stops there — no mention of default lengths, entropy values, or what a bulk response looks like.

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

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

The opening three fragments ('Secure random passwords. Passwords. Cryptographically secure random passwords') restate the same idea three times before reaching any new information. Only the parenthetical field list and the bulk/UUID clause earn their place, so the definition is padded rather than 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 no output schema and no return-value documentation, the description's 'in bulk' and UUID v4 hints carry some weight, but it never explains the response shape or whether UUID output is a separate mode the caller must request. All five parameters are optional, yet no defaults are stated anywhere. Adequate but with clear gaps for a generator with several optional knobs.

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 count, length, numbers, symbols, and uppercase with ranges and examples; baseline 3 applies. The description names four of those fields (length, symbols, numbers, uppercase) but also cites 'entropy' and 'UUID v4', neither of which exists as a parameter, which risks misleading an agent into looking for an entropy or UUID option.

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 identifies the resource (cryptographically secure random passwords) and adds scope beyond the name by mentioning bulk generation and UUID v4 output. However, it never states an explicit verb, and the repetition ('Secure random passwords. Passwords. Cryptographically secure random passwords') muddies rather than sharpens the purpose. An agent can guess what it does, but the framing is noun-phrase fragments rather than a clear statement.

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

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

There is no guidance on when to use this tool, when not to, or what alternatives exist. The sibling list contains no other password/UUID generator, so a routing conflict is unlikely, but the description still offers nothing about context, defaults, or constraints on invocation.

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, destructiveHint=false and openWorldHint=true, so the safety profile is covered by structured data. The description adds no behavioral context of its own — no output format, no note on defaults, no statement about performance or limits, and no clarification of how the HMAC/identification capabilities are triggered.

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 short and front-loads the core purpose, which is good. However, the first two clauses ('MD5 / SHA hashes of a text. Hash text.') are pure restatements of the title and name and consume space without adding information, leaving a three-clause capability list with no structure or priority.

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

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

With no output schema, the description should ideally indicate the shape of the result (e.g. a map of algorithm to hex digest), which it omits. The advertised HMAC and algorithm-identification behaviors are plausible extensions of a single text input but are never tied to parameters or return values, leaving the agent to guess how to invoke them.

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 documented in the schema, including the comma-list format and examples. The description's algorithm enumeration duplicates the schema's enum-like list rather than adding syntax, defaults, or edge-case behavior. Baseline 3 is appropriate when the schema already carries the parameter documentation.

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 (hashing text) and enumerates the supported algorithms, so an agent knows exactly what the tool computes. It does not need to differentiate from siblings since none of the other utilities overlap. The opening 'MD5 / SHA hashes of a text' plus 'Hash text.' is a restatement of the title and name, which slightly dilutes the clarity.

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

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

The description lists capabilities (multi-algorithm hashing, HMAC signing, algorithm identification) but gives no guidance on when to choose this tool, what the defaults are if 'algorithms' is omitted, or any prerequisites. Worse, HMAC signing conventionally requires a secret key and no such parameter exists, so the agent is nudged toward a capability it cannot configure.

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, and destructiveHint, so the safety profile is covered. The description adds behavioral context by disclosing the RDAP data source and the default behavior when 'ip' is omitted (caller's IP, country, city, ASN). It does not cover rate limits or error handling, but that is beyond the bar set by the annotations.

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

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

The description front-loads the purpose but includes redundancy: 'IP info.' repeats the opening, and 'Owner, network and country of an IP address' is restated as 'Who owns an IP address.' The sentences are short, but not every sentence earns its place.

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

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

For a simple, read-only, one-parameter lookup with no output schema, the description is fairly complete: it names the data source, lists the returned fields, and explains the default when the parameter is omitted. It could mention limitations or rate limits, but it covers the essential context an agent needs 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 coverage is 100%, so the schema already defines 'ip' as IPv4/IPv6 with empty meaning the caller's own IP. The description adds only that omitting it returns the caller's IP, country, city, and ASN, which is mostly output information rather than additional parameter semantics. 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?

States the resource (IP address) and the specific data returned (network name, range, CIDR, organization, country, registration date) via RDAP. This is clear enough to tell it apart from generic DNS or domain tools, though it does not name sibling tools explicitly. A 4 rather than 5 because sibling differentiation is implicit rather than stated.

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

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

No explicit when-to-use guidance or alternatives are given. The description explains what the tool returns and the default when 'ip' is omitted, but it never says when to choose this over dns_lookup, domain_whois, or country_info. This is minimal 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 readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so safety is covered. The description adds useful context (data source date-holidays CC BY 3.0, coverage breadth, localized names), but never states what the tool actually returns (a boolean, a holiday name, a list?) which is the key behavioral fact for a 'check' tool with no output schema.

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

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

The description asks 'Is this date a public holiday?', then 'Is it a holiday?', then again "plus 'is this date a holiday?' check" — three near-duplicate restatements of the same question before any new information. The redundancy wastes the most valuable front-loaded space.

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

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

With no output schema, the description carries the burden of explaining the return shape, and it never does. It also fails to differentiate from the sibling 'public_holidays', so an agent cannot reliably pick this tool or predict what it hands back.

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 country (ISO code), state, and date (YYYY-MM-DD). The description adds only the incidental detail of 'any year' and 'localized names', which maps loosely to country/state but provides no syntax or format beyond the schema. 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 makes the operation clear: a yes/no check of whether a date is a public/bank holiday, with stated scope (100+ countries, states/regions, any year). However, it never distinguishes itself from the sibling tool 'public_holidays', leaving the agent to guess which one produces a boolean check versus a holiday list.

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

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

There is no when-to-use guidance and no mention of alternatives, despite the near-identical sibling 'public_holidays' sitting right next to it. An agent has no stated rule for choosing between the two.

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 and destructiveHint=false, so the safety profile is covered. The description adds behavioral context beyond that — it discloses a "Fast HTML streaming parser" implementation trait — but omits error behavior for non-HTML/unreachable pages, caching, 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?

Front-loaded with the core purpose, which is good, but "title, description, image" is effectively stated twice (opening sentence and the field enumeration), and "Link preview" as a standalone fragment adds little. Wasteful repetition keeps it from scoring higher.

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

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

There is no output schema, so the description usefully enumerates the returned fields (title, image, favicon, site name, language, canonical URL, author, publish time, Twitter card, JSON-LD). Combined with annotations covering safety, an agent has enough to call and interpret the tool, though error/edge behavior is unaddressed.

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

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

Schema description coverage is 100%, so the schema already documents both url and jsonld; baseline is 3. The description's mention of "optional JSON-LD" corroborates the jsonld parameter but adds no syntax or format 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 opening sentence gives a specific resource and what is extracted (title, description, image of a web page), and the field list clarifies the scope. It does not name or distinguish itself from web-metadata siblings like check_url_status, expand_short_url, or extract_links, 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?

"Everything you need to build link previews" implies the use case (generating link previews / scraping page metadata), but there is no explicit when-to-use vs. alternatives guidance and no exclusions. Usage is only inferred from the field list.

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, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description usefully adds the output shape (payment, interest, full schedule) and supported options (down payment, extra payments, frequencies), but says nothing about error conditions or input constraints.

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 four sentences are front-loaded with the core purpose, but 'Loan / mortgage payments and schedule,' 'Calculate loan or mortgage,' and 'for loans and mortgages' restate the same subject three times, making the opening redundant rather than tight.

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 10-parameter calculator with no output schema, the description conveys the main results and several input options, which is adequate. Still, it does not explain the schedule/return structure or how the many term/amount parameters interact, leaving room for ambiguity.

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 10 parameters with examples. The description references some of them (down payment, extra payments, frequency, yearly summaries) but adds no syntax or constraint detail beyond the schema, so baseline 3 applies.

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

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

The description states a clear verb ('Calculate') and resource ('loan or mortgage') and enumerates the concrete outputs (monthly payment, total interest, amortization schedule). It is easily distinguishable from the diverse set of sibling utility tools, though it does not name any 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?

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. Since the tool is single-purpose this is less damaging, but the description gives no usage context beyond what it computes.

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 and destructiveHint=false, so the safety profile is covered. The description usefully adds that times are returned in the local time zone auto-detected from coordinates, but says nothing about accuracy, edge cases (polar day/night), or failure modes beyond that.

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 opening 'Moon phase and illumination. Moon phase and times.' duplicates the title and name without adding information, and 'Moon phase' is repeated later. The long enumerations are front-loaded reasonably but the redundant opening sentences do not earn their 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 no output schema, the description usefully enumerates the returned values (sunrise/sunset, twilight stages, golden hour, illumination, moonrise/moonset, next full/new moon), which compensates for the missing return documentation. It is nearly complete, though it omits edge-case behavior.

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 lat/lon/date/tz are already documented in the schema. The description restates the tz auto-detection behavior that the schema already specifies, adding no syntax or format detail beyond it. 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 specific resources (sun/moon astronomical data) and scope (any coordinates and date), so an agent knows this is an astronomy computation tool. However, the opening two sentences ('Moon phase and illumination. Moon phase and times.') are redundant and it never distinguishes itself from the sibling sunrise_sunset tool, despite heavy overlap.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives. The overlap with the sibling sunrise_sunset is left unresolved, so an agent cannot tell which tool to prefer for solar-only 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 cover the safety profile (readOnlyHint, destructiveHint=false, openWorldHint), so the description correctly focuses on scope: a 7,793-food database, 36 nutrients returned, per-100g or arbitrary amounts, and portion-size units. It stops short of explaining behavior for unmatched foods or partial failures, which would be the remaining valuable detail.

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

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

The first sentence duplicates the title verbatim and the fragment 'Recipe / meal totals.' restates the sentence that follows it, so two of the four sentences are largely redundant. The genuinely informative content (coverage, nutrients, units) is present but not front-loaded.

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

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

For a one-parameter, read-only aggregation tool with no output schema, the description adequately conveys what comes back (list of nutrients, totals) and the input units. Only edge-case behavior and any limits on item count are missing.

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

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

There is a single parameter and schema description coverage is 100%, with the schema already spelling out the 'food:grams' syntax and JSON alternative. The description adds only indirect context ('per 100 g or for any amount, with common portion sizes'), 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 gives a specific resource (calories and macros for a list of ingredients) and states the operation is aggregation into recipe/meal totals. It is distinguishable from nutrition_search by focusing on summing multiple items rather than lookup, though it never names that sibling, so the differentiation requires inference.

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

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

Usage is implied rather than stated: 'Calculate totals for a whole recipe or meal in one request' tells the agent the intended scenario. It does not say when to prefer this over nutrition_search, nor any prerequisites or exclusions.

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

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

Annotations already declare readOnlyHint, openWorldHint, and destructiveHint=false, so safety is covered. The description adds substantive context beyond them: dataset size (7,793 foods), breadth of returned nutrients (36), and the per-100 g / any-amount / portion-size semantics of the values.

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 resource and mostly efficient, but 'Nutrition facts of foods (USDA). Search foods.' is redundant — the title is restated and the verb repeated before the informative sentence begins.

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

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

There is no output schema, so the description carries the burden of explaining returns; it does so well by enumerating the nutrient set, units basis (per 100 g or any amount), and portion-size support. It is nearly complete for a search tool, missing only guidance on result ranking/pagination.

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 q, limit, and category are already documented in the schema. The description adds nutrient/portion semantics but no detail on parameter behavior such as how 'category' interacts with 'q' or the meaning of the limit range, 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 ('Search foods', 'Nutrition facts of foods (USDA)') and quantifies scope (7,793 generic foods, 36 nutrients). However, it never distinguishes itself from the sibling nutrition_calculate, so an agent must infer the split between searching and calculating.

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

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

Usage is implied through feature statements ('Calculate totals for a whole recipe or meal in one request', portion sizes), but there is no explicit when-to-use guidance, no exclusions, and no mention of the closely related nutrition_calculate sibling as the alternative for that calculation path.

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, and destructiveHint=false, so the safety profile is covered. The description adds genuine behavioral value by disclosing coverage breadth and input tolerance for spaces/dashes, but it also advertises a two-code distance capability the single-code schema cannot support, which muddies rather than clarifies behavior.

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

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

The first three clauses ('Place of a postal / ZIP code', 'Look up a postal code', 'Postal code lookup...') restate the same idea before any distinguishing detail arrives. The useful content (coverage, returned fields, input tolerance) is back-loaded, so the opening is not front-loaded with value.

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

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

With only two required parameters, no output schema, and read-only annotations, the description does enough to convey return fields (place name, region, province, coordinates). However, the unsupported 'distance between two postal codes' and 'validation' claims leave the agent unsure whether those are real modes of this tool or separate 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%, so the baseline is 3; the description adds format tolerance ('accepts codes with or without spaces and dashes') beyond the schema's terse examples for 'code'. It adds nothing about the 'country' parameter's ISO format, but the schema already handles that.

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 concrete verb+resource (look up a postal/ZIP code) and enumerates the returned fields plus coverage (121 countries, 1.8M codes), so the agent knows exactly what this tool produces. It does not, however, differentiate itself from plausible siblings such as reverse_geocode, city_search, or distance_between_places, and its mention of 'distance between two postal codes' blurs that boundary further.

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

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

There is no explicit when-to-use guidance and no named alternative among the ~45 siblings. The claim that it computes 'distance between two postal codes' actually invites confusion, since the schema accepts only a single code and country, so an agent gets no signal about when to prefer this tool over distance_between_places.

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, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds genuinely new context: the coverage footprint (100+ countries, states/regions, any year), localized naming, and the upstream data source with license. It omits return shape and rate/limit behavior, but for a read-only lookup this is solid.

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?

"Public holidays of a country. Holidays of a year." is largely a restatement of the title and wastes the front position. The third sentence is dense and useful, and the data-source line is a quiet but legitimate attribution, so the result is adequate rather than tight.

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?

Read-only annotations plus a fully described 5-parameter schema and no output schema mean the description need not carry much. The gap is the advertised 'is this date a holiday?' check: no date parameter exists in the schema, so an agent following that claim has no way to invoke it and no explanation of where the check lives.

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 lang, year, state, types and country. The description lightly echoes these concepts (localized names, any year, states/regions, public and bank holidays) but adds no syntax or format detail beyond the schema's own examples, 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 concrete resource and scope: public and bank holidays for 100+ countries and their states/regions, any year. However, it claims to include an "'is this date a holiday?' check" that overlaps with the dedicated sibling is_public_holiday without routing the agent, so the boundary between the two tools is blurred rather than clarified.

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

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

No when-to-use guidance and no explicit alternative is named, even though is_public_holiday in the sibling list is the obvious competing choice for single-date checks. The description actually muddies this by advertising the same check here, so the agent gets no tie-breaker.

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, and destructiveHint=false. Beyond those, the description adds genuinely useful behavioral context: 'Fast city-level geocoding for 171,000 places worldwide' and 'No rate-limited upstream,' which tells the agent about latency and throttling expectations. It also implies the return content (town, region, country, time zone), partially compensating for the missing output schema.

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

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

The first two sentences restate the title and name ('Nearest city to a latitude/longitude' / 'Reverse geocode coordinates'), which is redundant front-loading. The middle sentence then lists capabilities that arguably belong to other tools, diluting the message rather than tightening it.

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

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

With no output schema, the description wisely hints at returned fields (nearest town, region, country, time zone), which is helpful. But it omits parameter behavior details and conflates this tool with place-search functionality, leaving an agent uncertain about the exact return shape and scope.

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

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

Schema description coverage is 100%, so lat, lon, and minPopulation are already documented with examples. The description adds no syntax or format detail 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 specific verb+resource: converting coordinates (lat/lon) to the nearest city. However, it then muddies its own scope by claiming 'place search by name and nearby places within a radius,' which overlaps sibling capabilities like city_search. The core operation is clear but the added capabilities blur boundaries.

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

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

No explicit when-to-use or when-not-to-use guidance, and no alternatives are named despite obvious candidates (city_search for name lookups, timezone_by_coordinates for time zone by location). Usage must be inferred entirely from the tool name and the stated inputs.

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, and destructiveHint=false, so the safety profile is covered. The description adds scope context by revealing it also processes whole texts (per word and per line, haiku detection), but says nothing about result count, pagination, or error behavior beyond what the schema covers.

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

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

The first two sentences are redundant with the title and each other ('Rhymes of an English word. Rhyming words.'), wasting the prime front-loaded position. The core capability sentence is dense but packed with tangentially related features rather than the primary rhyming function.

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 lookup tool with full schema coverage and no output schema, the description covers the functional scope well, including text-level syllable counting not obvious from the params. Return format and result structure are unstated, but annotations and schema carry much of the load.

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 every parameter (word, all, limit, syllables) is already documented in the schema. The description mentions syllable counts, loosely connecting to the syllables param, but adds no syntax or format details beyond the schema. Baseline 3 is appropriate.

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

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

The description names a concrete resource (rhymes, syllable counts, pronunciation) and adds distinctive capabilities like whole-text syllable counting and haiku detection. However, the opening two sentences ('Rhymes of an English word. Rhyming words.') largely restate the name/title, and it never distinguishes itself from neighbors like synonyms or dictionary_define.

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 offers use-case context ('perfect for songwriting, poetry and readability tools') but gives no when-to-use vs when-not guidance and never names an alternative like synonyms or dictionary_define. Usage is only implied.

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

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

Annotations already declare readOnlyHint, openWorldHint and destructiveHint=false, so safety is covered. The description goes beyond them by disclosing the shape of the result: the matching rule, sitemaps, and crawl-delay, which matters because no output schema exists. It omits any note on network failures or robots.txt fetch errors.

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 leading title restatement plus the bare fragment 'Check URL.' are redundant and waste space. The final sentence is dense and front-loads the useful information, but the redundant middle sentence dilutes it.

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 two-parameter read-only tool with no output schema, the description supplies the key return contents (matching rule, sitemaps, crawl-delay) and the crawl-permission framing. Only error/edge behavior and the role of the agent parameter are left unspecified.

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

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

Schema description coverage is 100%, with both parameters documented and exemplified, so the baseline is 3. The phrase 'for any user agent' adds a little framing but is mildly ambiguous given the optional agent parameter, and no default/omission behavior for agent is explained.

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 and resource: checking whether a URL is crawlable per the site's robots.txt. The added detail (matching rule, sitemaps, crawl-delay) clearly separates it from near siblings like check_url_status, sitemap_urls, and seo_audit.

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

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

Usage is implied by the tool's narrow purpose (robots.txt compliance checks), but there is no explicit when-to-use, when-not-to-use, or named alternative such as check_url_status for reachability versus crawl permission. An agent must infer the boundary itself.

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, and destructiveHint=false, so the safety profile is covered. The description adds that results include 'a score, a grade and fixes to apply', which is genuinely useful output context, but it says nothing about rate limits, network failures, or fetch behavior for an open-world tool.

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

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

Three sentences, two of which are near-verbatim restatements: the first duplicates the title and the second ('Check security headers') is subsumed by the third. Only the final sentence carries new information, so the text is repetitive rather than concise.

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

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

With no output schema, the description must convey what comes back, and it does: a score, a grade, and fixes to apply. For a one-parameter read-only tool this covers the essentials, though it omits failure modes for an open-world fetch.

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?

There is a single parameter with 100% schema description coverage (the schema gives the URL type and an example), so the baseline is 3. The description does not add any format or constraint detail beyond 'any website'.

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 and resource ('Check the HTTP security headers of any website') and enumerates the concrete artifacts checked (HSTS, CSP, X-Frame-Options, Referrer-Policy, Permissions-Policy), which separates it from generic siblings like check_url_status or website_technologies. It stops short of explicitly contrasting itself with those siblings, so it falls just 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?

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as check_url_status or seo_audit, which an agent could easily confuse with this tool. The phrase 'of any website' is the only usage signal, which is weak.

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 (readOnlyHint=true, destructiveHint=false, openWorldHint=true), and the description adds that the whole audit happens 'in one call' and returns a 0-100 score plus an issue list. That output shape is meaningful since there is no output schema, though nothing is said about auth, rate limits, or failure behavior for unreachable URLs.

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 core sentence is front-loaded and information-dense, but 'On-page SEO audit of a URL' is repeated from the title and again in the body, and the fragment 'Audit page.' adds nothing. Roughly a third of the text is redundant restatement.

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

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

With no output schema, the description usefully states what comes back (score 0-100, list of issues) and enumerates the checks, which is sufficient for a single-parameter read-only tool. It stops short of describing scoring methodology or issue severity, but nothing essential to invocation 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?

One parameter with 100% schema description coverage, so the schema already documents the url input including an example. The description adds no format, scheme, or edge-case guidance beyond that, which is the expected baseline 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?

Specific verb+resource ('On-page SEO audit of a URL') plus an enumeration of the exact checks performed (title, meta, H1, canonical, noindex, alt text, lang, viewport, OG, thin content, speed, HTTPS). This clearly separates it from generic siblings like check_url_status or website_technologies, though it never names those alternatives directly.

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

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

Usage is implied by the checklist of checks, so an agent can infer this is the comprehensive page-level SEO pass rather than a single-signal probe. However, there is no explicit when-to-use, when-not-to-use, or routing to siblings such as security_headers_check or check_url_status.

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 (readOnlyHint=true, openWorldHint=true, destructiveHint=false), and the description adds real behavioral context beyond them: it follows sitemap indexes and .gz files, and surfaces lastmod, priority and changefreq. It stops short of describing pagination or failure behavior for sites without a sitemap.

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

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

The first two sentences restate the title and the tool name ('URLs listed in a website's sitemap. Extract sitemap URLs.') before reaching the useful content, so roughly a third of the text is redundant, though the remaining content is front-loaded and dense.

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

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

With no output schema, the description usefully names the returned fields (lastmod, priority, changefreq) and the sitemap-traversal behavior. Missing only edge-case guidance (no sitemap present, gzip failure) for a fully complete picture of a simple three-parameter read tool.

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

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

Schema description coverage is 100%, so the schema already documents url, limit and contains with examples. The description only gestures at 'Filter by text' (contains) and mentions lastmod/priority/changefreq, which are return fields rather than parameters, so it adds little 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+resource ('Extract sitemap URLs... Get all URLs of a website from its sitemaps') and adds mechanics (found via robots.txt, follows sitemap indexes and .gz files) that clearly separate it from siblings like extract_links, robots_txt_check, or seo_audit.

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

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

Usage is implied by the resource ('from its sitemaps, found via robots.txt'), so an agent can infer this is the sitemap-discovery tool, but there is no explicit when-to-use/when-not statement or named alternative for related needs such as crawling links or auditing SEO.

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, non-destructive, openWorld). The description adds genuine value beyond them: it discloses the return shape (ranked suggestions, offsets, auto-corrected text) and the format=bing compatibility mode, which matters since there is no output schema.

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

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

Front-loaded with the core purpose and kept to a few sentences. There is mild redundancy between the title, 'Check spelling', and the opening phrase, but nothing is 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?

For a read-only text-processing tool with a fully documented schema but no output schema, the description supplies the missing return-value context (suggestions, offsets, corrected text) and language/format scope. A brief note on limits or error behavior would make it fully complete.

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

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

Schema coverage is 100%, so all seven parameters are already documented with examples in the schema. The description only echoes the format=bing behavior and adds no syntax or default details beyond what the schema already provides, so baseline 3 applies.

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

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

States a specific verb and resource ('English spell check', 'flags misspellings') and conveys scope (US/UK English, ranked suggestions). It is clearly distinguishable from siblings like dictionary_define or detect_language, though 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?

Usage is implied by the purpose (check spelling of text) and the Bing-compatibility note hints at a migration use case, but there is no explicit when-to-use versus dictionary_define/detect_language guidance and no stated prerequisites or exclusions.

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

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

Annotations already cover the safety profile (readOnly, openWorld, non-destructive), and the description adds genuinely useful behavioral context: extractive TextRank, 50+ language support, and the explicit claim of no AI cost and no invented content. It does not cover rate limits or fetch failures on URLs, but adds real value 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?

The opening two sentences ('Summarize a text or web page. Summarize a text or URL.') are near-duplicates that consume space without adding meaning. The rest is efficient, but the redundancy is real waste.

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

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

For a 5-parameter tool with no required fields and no output schema, the description should clarify that the caller must supply text OR url; it merely implies this. It does cover output-side traits (keywords, reading time), which partly compensates.

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 five parameters. The description corroborates the URL and language aspects but adds no syntax or interplay detail (e.g., how ratio and sentences interact). 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 verb+resource (summarize text/URL) and adds the mechanism (TextRank) and outputs (keywords, reading-time). It is distinguishable from siblings like extract_keywords or link_preview, though it never explicitly names 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?

There is no when-to-use or when-not-to-use guidance and no named alternatives, despite a crowded sibling set (extract_keywords, link_preview, spell_check). Usage is only implied by the verb.

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, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds genuinely useful behavior beyond that: times are emitted in a local time zone auto-detected from the coordinates. It still says nothing about accuracy caveats, polar day/night edge cases, or date-range limits, which for an astronomical calculator would be worth stating.

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 core sentence is dense and front-loads the returned data well, but the opening two fragments ('Sunrise, sunset, twilight and golden hour.' and 'Sun times.') are redundant restatements of the title and consume the most prominent position without adding information. Trimming them would sharpen the entry point.

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

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

With no output schema, the description correctly carries the burden of enumerating return values, and it does so thoroughly (all sun events, twilight bands, golden hour, moon data). It is slightly thin on output formatting (e.g. how day length is expressed) and edge-case behavior, but an agent has enough to call and interpret the tool.

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

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

Schema description coverage is 100%, so all four parameters (lat, lon, tz, date) are already documented with examples and defaults in the schema. The description's time-zone statement merely restates the schema's tz 'auto' semantics and adds no format, range, or edge-case detail beyond it, 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 concrete resource and enumerates exactly what is computed: sunrise, sunset, solar noon, day length, three twilight bands, golden hour, plus moon phase/illumination/rise/set. That is far more specific than the title alone. It does not, however, distinguish itself from the sibling 'moon_phase' tool even though it duplicates that capability, so sibling differentiation is incomplete.

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

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

Usage is implied by the stated inputs ('for any coordinates and date'), which tells an agent this is the coordinate-based sun/moon calculator. There is no explicit when-to-use versus alternatives, and no mention of the overlapping 'moon_phase' or 'timezone_by_coordinates' siblings, nor any prerequisite (e.g. valid coordinates, date range limits).

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/non-destructive, so the safety profile is covered. The description adds genuine behavioral value beyond that: result coverage (147,000 words), that results are ranked and grouped by meaning, include part of speech and definitions, and that inflected forms are normalized (running → run).

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 core purpose, but the body redundantly restates 'synonyms and antonyms' three times across consecutive sentences. The word-count/coverage figure earns its place; the repetition does not.

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

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

With no output schema, the description usefully characterizes the return payload (ranked, grouped by meaning, POS-tagged, definitions included), which is what an agent needs to consume results. It omits result volume/limit behavior, a minor gap given the schema documents the limit parameter.

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 all three parameters are self-documented, so the baseline is 3. The description mentions 'part of speech' and definitions but adds no syntax, default, or filtering semantics beyond what the schema already states.

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 resource (synonyms/antonyms for an English word) with concrete scope (147,000 words, inflected forms). It does not, however, distinguish itself from close siblings like dictionary_define or rhymes, which an agent could plausibly confuse it with.

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

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

There is no explicit when-to-use or when-not-to-use guidance. Nothing tells the agent to prefer this over dictionary_define for definitions or rhymes for sound-alikes, so the routing decision is left entirely to inference from the name.

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, openWorld, non-destructive), so the bar is lower. The description still adds real behavioral value by enumerating the return payload (IANA zone, current local time, UTC offset, abbreviation, DST flag), which matters since there is no output schema.

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

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

The substantive content is front-loaded well, but the opening two fragments ("Time zone of a latitude/longitude. Time zone for coordinates.") restate the title and each other, wasting the most valuable position in the description.

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 3-parameter read-only lookup with no output schema, the description covers inputs and enumerates outputs adequately. Only the sibling distinction against convert_time_zone is left 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 coverage is 100% and each parameter is documented in the schema, so the baseline is 3. The description only lightly reinforces datetime semantics ("offset at that moment") and adds nothing about accepted coordinate formats beyond the schema examples.

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: "Get the IANA time zone for any latitude/longitude." An agent can immediately tell this is a coordinate-to-timezone lookup, though it never names the sibling convert_time_zone to draw the boundary 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?

Usage is implied by the coordinate-based framing, and the optional datetime clause hints at the when-to-pass case. However, there is no explicit when-to-use vs convert_time_zone guidance and no exclusions or prerequisites 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 cover the safety profile (readOnlyHint=true, destructiveHint=false, openWorldHint=true), so the bar is lower; the description still adds real value by disclosing that validation is an offline algorithmic check with no account lookup or network dependency, and by listing what it checks and extracts. It does not describe the response shape for invalid input, but the behavioral disclosure is well beyond the annotations.

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

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

The opening three fragments ('Validate and parse an IBAN. Validate IBAN. Validate any IBAN...') are near-duplicate restatements that consume the front-loaded position without adding information. The remaining content is dense and useful, but two of the first sentences do not earn their 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 tool with no output schema, the description covers what is verified, what is returned (bank code, branch code, account number, SEPA flag), and the offline nature of the check. The only gap is behavior on invalid input, which is minor given the tool's simplicity.

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

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

There is a single parameter with 100% schema description coverage, which includes the format hint ('spaces allowed') and an example, so the baseline is 3. The description only loosely reinforces this by mentioning 'formatted and electronic forms' and adds no syntax 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 names a specific verb (validate/parse) and resource (IBAN), and enumerates exactly what is validated: checksum, length, country format, national check digits. No sibling tool in the list is close enough to require explicit differentiation, but the first three fragments ('Validate and parse an IBAN. Validate IBAN. Validate any IBAN...') restate the same idea without adding precision.

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

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

There is no explicit when-to-use vs. when-not guidance, but the closing note 'Offline algorithm, no account lookups' implicitly scopes the tool: use it for structural validity, not for confirming that an account exists. With no competing sibling to route against, this is adequate but inferred rather than 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=true, destructiveHint=false and openWorldHint=true, so safety basics are covered. The description adds useful scope detail ('130+ technologies', category coverage) that partially substitutes for the absent output schema, though it says nothing about rate limits, auth needs or failure behavior.

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

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

The first and second sentences restate the title ('Technologies used by a website. Detect technologies.'), which is pure redundancy. The category enumeration is front-loaded and informative, but the opening wastes space before delivering the actual value.

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

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

For a one-parameter, read-only detection tool, the description is largely complete: it tells the agent what class of technologies is returned, which compensates for the missing output schema. It could still note the return shape (e.g. category-to-technology mapping) more explicitly.

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?

There is a single parameter and schema description coverage is 100%, with the schema itself supplying the URL format example. The description adds no extra semantics about the url argument. Baseline 3 applies when the schema does all the work.

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 ('Detect') and resource ('technologies a website uses'), then enumerates the covered categories (CMS, frameworks, analytics, chat, CDN/hosting) and scope ('130+ technologies'). This implicitly distinguishes it from near-neighbors like seo_audit, security_headers_check and dns_lookup, though 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?

'Great for lead generation and competitor research' gives intent-level context but never states when to call this versus alternatives such as seo_audit or check_url_status. Usage is implied by the use-case framing rather than spelled out.

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