ISO country GN

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

With no annotations, the description carries the full burden. It does disclose one notable behavior: 'Task text discarded', and it mentions return contents. However, it does not clarify side effects, cost implications of 'pay-per-call', permissions, or what happens to the many optional inputs. This is partial transparency, not comprehensive.

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

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

The description is two tight sentences with no filler. The main purpose is front-loaded, and the 'Task text discarded' note is a useful extra. It loses a point only because 'Monid' is jargon that is not expanded, making the concise text less self-contained.

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

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

Given 9 optional parameters, no output schema, and no annotations, the description is too thin. It does not explain why there are nine unrelated-looking parameters, how they relate to the returned CLI setup or MCP hops, or which inputs matter for a typical call. An agent would need significant additional inference to use this tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The tool description adds no parameter-level meaning beyond saying that some values are 'discarded'. Baseline 3 is appropriate since the schema, not the description, does the heavy lifting.

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

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

The description states a clear action: 'Find a public pay-per-call tool gateway (Monid)', and specifies what it returns: 'CLI setup, how-it-works, skill file, and remote MCP hops'. This is a specific verb+resource combination that distinguishes it from the sibling utility tools, though 'Monid' is unexplained and the phrase 'pay-per-call' could confuse.

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 mention of prerequisites, and no exclusion criteria. The 27 sibling tools are not referenced, so an agent has no way to know when this index lookup is the right choice over a more targeted tool like web-fetch or normalize-url.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses only that no browser is launched, but omits whether it makes network requests, what indicates a URL is 'ok', and how errors or redirects are handled.

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

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

The description is concise and front-loaded with the core action, and the 'No browser is launched' clause is a valuable distinction. It is not padded, though it sacrifices important detail for brevity.

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

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

For a tool with 9 optional parameters, no annotations, and no output schema, this description is insufficient. It does not clarify which parameters are relevant to the URL check, what response the agent should expect, or how to interpret success/failure.

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 tool description itself adds no parameter-level meaning, and the schema's eclectic mix of parameters (city, json, timezone, query) is not reconciled with the stated URL-checking purpose.

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 action (check) on a specific resource (URL) with a clear outcome (can be opened). The clause 'No browser is launched' helps differentiate it from browser-based sibling tools like playwright-url-ok, though it leaves the exact checking method somewhat ambiguous.

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 some usage context by implying a lightweight check without launching a browser, which can route an agent away from playwright-url-ok. However, it does not explicitly name alternatives or state when to use this tool versus sibling tools like fetch-status, web-fetch, or normalize-url.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only says the expression is discarded. It does not state whether the tool returns a result, how invalid expressions are handled, whether any network or filesystem access occurs, or what side effects exist.

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 only two short sentences and the operation is front-loaded. The second phrase 'Expression discarded' adds little and is ambiguous, but there is no redundancy or wasted bulk.

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 many parameters, no annotations, and no output schema, a single sentence is far from sufficient. Missing are the required input, return behavior, error semantics, and any context for when the call makes sense.

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

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

The schema exposes only unrelated string parameters such as ref, url, city, feed, host, json, path, and query, and additionalProperties: false prevents passing an 'expression' key. The description never maps the arithmetic expression to a concrete parameter, so the agent cannot determine what to pass.

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 operation: evaluating 'a+b style arithmetic', which is distinct from sibling URL/JSON/timezone validation tools. However, the phrase 'Expression discarded' is ambiguous, and the schema exposes no matching expression parameter, so the purpose is clear but not fully actionable.

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 calc-eval versus siblings such as validate-json, search-query-len, or web-fetch, and no examples or exclusions are provided. The description leaves all selection decisions to inference.

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

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

With no annotations, the description carries the burden, and it does add one meaningful behavioral guarantee: page content is not stored. However, it does not disclose behaviors such as whether the URL is fetched, how errors surface, or what happens to the many non-URL inputs.

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

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

Two short sentences with the primary behavior front-loaded and a useful privacy note second. No filler, and every sentence adds information.

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

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

The nine-parameter schema, no output schema, and no annotations require a richer description. The description only addresses the URL case and never explains how ref, city, feed, json, host, or path relate to the tool, so an agent cannot reliably decide which parameter(s) to populate.

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 applies; the tool description itself adds little parameter-level meaning. The schema already describes each parameter, and the description mostly states output behavior rather than input semantics.

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

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

The description states a specific action and output: return host, scheme, and HTTP status for a URL. It is clear about what the tool does for a URL, though it does not explicitly differentiate it from siblings like normalize-url or fetch-status.

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

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

No guidance is given on when to use citation over its 26 sibling tools. The only hint, 'Page content is not stored,' is a privacy trait rather than an explicit when-to-use or exclusion.

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

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

With no annotations provided, the description carries the full burden. It does disclose a meaningful privacy behavior: 'No identifiers are retained.' However, it doesn't clarify whether classification is local, what side effects occur, or what the output format will be, leaving behavioral transparency incomplete.

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 text is short, front-loaded, and each sentence contributes some information. However, it is under-specified rather than appropriately complete for a tool with nine optional parameters and no output schema.

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

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

Given the absence of annotations, output schema, and behavioral details, this description is not complete enough. An agent cannot determine what the classification result looks like, which input to supply, or how the result should influence tool selection.

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 itself adds no parameter-level detail, but the schema already explains each of the nine optional fields adequately.

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 says the tool 'show[s] how this request is classified', but it never defines what classification means or what 'compatibility' refers to. This is vague and doesn't distinguish the tool from siblings like normalize-url, validate-json, or search-query-len.

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

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

No guidance is given about when to use this tool versus any sibling tool. The description doesn't mention that all inputs are optional, which parameter to choose for a given request type, or any context for when classification is needed.

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

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

With no annotations provided, the description carries the burden of explaining behavior. It does state the core behavior (splitting a hostname into labels) and a key exclusion (no WHOIS/ownership data). However, it does not disclose output format, error behavior, or how it treats the many unrelated optional parameters, so transparency is partial.

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

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

The description is a single, front-loaded sentence with no filler. It is efficient and immediately states the action. Its brevity is a strength, though it may be slightly too terse given the tool's nine-parameter schema and lack of annotations.

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

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

The tool has 9 optional parameters, no required parameters, no output schema, and no annotations. The description only covers the hostname-splitting behavior and does not mention which parameter to pass, what the return value looks like, or how to handle the unrelated parameters. An agent navigating this tool alongside many shape/ok siblings would need more context.

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 even without parameter details in the tool description. The description's 'hostname' wording aligns with the 'host' parameter, but it does not clarify which of the 9 optional parameters are relevant or how to select among them. It adds no parameter-level meaning beyond what the schema already provides.

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

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

The description gives a specific verb and resource: 'Split a hostname into labels.' It also usefully scopes the tool by excluding WHOIS or ownership data, which helps set expectations. It does not explicitly contrast with sibling shape tools like github-repo-shape or jira-key-shape, but the resource named is clear.

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

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

There is no guidance on when to use this tool versus siblings such as normalize-url, browser-url-ok, or github-repo-shape. The phrase 'without WHOIS or ownership data' hints at a pure syntactic check, but there are no explicit when-to-use, when-not-to-use, or alternative recommendations.

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

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

With no annotations present, the description carries the behavioral burden and largely meets it: it discloses the HTTP method, the public-URL constraint, and the fact that only status is returned. It does not discuss redirects or timeout behavior, but for a read-only HEAD probe this is a solid level of disclosure.

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

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

One sentence, front-loaded with the verb and resource, with zero filler. Every word earns its place.

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

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

For the primary URL-status case, the description is sufficient, but the tool exposes several unrelated optional schema parameters (ref, city, feed, json, path, etc.) and has no output schema or annotations. The single URL-focused sentence does not clarify whether those parameters are alternative modes or irrelevant, nor does it specify the exact form of the returned status.

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 parameters are already documented at the schema level; the description adds no parameter-level meaning. The visible parameter descriptions are explicit (for example, 'JSON text to validate; discarded after the check'), so the baseline of 3 is appropriate.

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

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

The description names a specific verb ('HEAD'), a specific resource ('a public URL'), and a precise output ('status only'), which cleanly separates it from sibling tools like web-fetch or browser-url-ok. An agent can tell what this tool does 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 intended use is implied: pick this tool when only the HTTP status of a public URL is needed. However, it does not explicitly state when not to use it or point to alternatives such as web-fetch for content or browser-url-ok for rendered availability checks.

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

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

No annotations are present, so the description carries full responsibility for behavioral disclosure. 'Path discarded' is the only behavioral hint, and it is ambiguous about whether it refers to the path input parameter or the URL path. The description does not disclose what parsing produces, whether any normalization/validation happens, or whether the tool has side effects.

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

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

The description is short and front-loaded with its main purpose, which is good. But 'Path discarded' is cryptic and does not clearly earn its place; it raises more questions than it answers, especially in the context of Figma URLs where path components matter.

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 9 parameters, no output schema, no annotations, and many URL-related sibling tools, this description is too thin. It does not explicitly direct the agent to pass the Figma URL in the 'url' parameter, does not describe what the parsed result looks like, and does not explain how to distinguish this tool from normalize-url or browser-url-ok. The description is minimally usable but not complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by indicating that the 'url' parameter should be a Figma file URL, which the schema's generic 'HTTPS URL to normalize or cite' does not convey. 'Path discarded' also clarifies that the path input is not used, though this is partially redundant with 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 uses a specific verb and resource: 'Parse a Figma file URL.' This distinguishes it from generic URL or shape tools like normalize-url and domain-shape. However, the appended 'Path discarded' is ambiguous, since a Figma file URL's file key lives in its path, which slightly muddies the core purpose.

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

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

The context of use is implied: this tool is for Figma file URLs, not arbitrary URLs. But the description does not explicitly say when to prefer this tool over sibling tools, nor does it mention any exclusion like 'for generic URLs, use normalize-url instead.'

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

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

With no annotations provided, the description carries the full behavioral burden. It does disclose the key trait 'No disk access', but it does not describe what 'safe' means, what the tool returns, how invalid paths are handled, or why the schema includes eight unrelated parameters such as url, city, feed, json, and zone.

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

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

Two short sentences, front-loaded with purpose followed by a key behavioral caveat. There is no wasted wording; every element 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 tool with nine optional parameters, no annotations, no output schema, and many sibling tools, the description is far too sparse. It omits return behavior, parameter relationships, and any usage context, leaving an agent without enough information to predict outcomes confidently.

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 nine parameters are already documented in the schema. The tool description adds no parameter-level meaning beyond identifying path as the focus, which meets the baseline but does not explain the presence or role of the unrelated parameters.

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

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

The description names a specific action ('Check whether a path looks safe') and a clear resource ('path'), and 'No disk access' adds a useful safety qualifier. It is clear, though it does not explicitly differentiate from sibling *-ok tools, and the 9-parameter schema introduces some ambiguity about 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?

No when-to-use or when-not-to-use guidance is provided, and no alternative tools are mentioned. 'No disk access' is the only contextual signal implying safe, non-I/O path validation, but no condition or exclusion is 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?

With no annotations, the description carries the full burden and does disclose one useful behavioral fact: the lookup goes through Open-Meteo. However, it does not mention whether this is a live network call, what happens to unused input parameters, rate limits, or any state changes, so transparency is only partial.

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

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

The description is a single front-loaded sentence with no filler: output first, data source second. It could earn a 5 only if it added parameter mapping or usage context while staying equally 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 tool with nine parameters, no required fields, no output schema, and no annotations, this one-sentence description leaves too much unspecified: which inputs are relevant, what the coordinate format/order is, and how it differs from weather-hint. The core purpose is present, but the calling context is incomplete.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning; it does not even map 'a place' to the likely city parameter among the nine loosely related keys.

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

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

The description clearly identifies the tool's function: returning latitude and longitude for a place, using Open-Meteo as the data source. It lacks a direct verb like 'get' or 'look up' and does not explicitly differentiate geo-hint from siblings such as weather-hint, 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?

No guidance is given about when to call geo-hint instead of a sibling tool. The description only states the operation and never says when to avoid it or which alternative to prefer.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not mention validation behavior, error handling for non-GitHub URLs, return format, or the fact that the schema includes many unrelated parameters that are discarded.

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

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

The description is a single, front-loaded sentence with no wasted words. It is appropriately economical, though it is too brief to carry the behavioral and usage context an agent needs.

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 annotations and no output schema, the description is under-specified. The agent is not told what the returned owner/repo shape looks like, what happens for invalid or non-GitHub URLs, or that the many extra schema parameters are irrelevant to this 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 coverage is 100%, so the baseline is 3. The description adds value by identifying 'url' as the meaningful parameter for GitHub parsing, whereas the schema describes it only as an 'HTTPS URL to normalize or cite'. This focus helps the agent select the right parameter among nine optional ones.

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 ('Parse') and resource ('owner and repo from a GitHub URL'), making the tool's core intent clear. It does not explicitly contrast with sibling shape tools like figma-url-shape or jira-key-shape, but the GitHub-specific wording is sufficiently distinctive.

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 such as normalize-url, domain-shape, or browser-url-ok. The description only states what the tool does, leaving the agent to infer context from the name and 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?

The description discloses one behavioral trait: titles are discarded, so only the count is relevant. However, with no annotations provided, the description carries the full burden and does not explain fetch behavior, return format, failure modes, or the fact that the nine input parameters appear unrelated to HN front-page counting.

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 extremely concise, with two short sentences that each add value: the first states the primary action, and the second clarifies an output characteristic. There is no filler or redundant information.

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

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

Despite the simple stated purpose, the tool has nine optional input parameters and no output schema or annotations. The description does not explain whether any arguments are needed, what the count looks like, how 'current' is determined, or how to handle the seemingly unrelated parameters, making the definition incomplete for a calling agent.

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

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

The input schema has 100% description coverage, and each parameter has its own description, so the schema already documents parameter semantics. The top-level description adds no meaning to the parameters and does not clarify why parameters like 'ref', 'city', or 'json' are relevant to counting Hacker News stories.

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: 'Count current Hacker News front-page stories.' This clearly identifies the tool's core function and distinguishes it from fetching or validating tools. However, 'Titles discarded' is ambiguous and the description does not explicitly differentiate from sibling tools such as web-fetch or fetch-status.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention prerequisites, exclusions, or a preferred scenario beyond counting HN stories. 'Titles discarded' implies a use case where only counts matter, but this is not made explicit.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It discloses no behavior at all: no return format, no side effects, no auth needs, no rate limits, and no indication of what happens when called. The schema parameter descriptions mention discarded values, but the tool description itself is behaviorally empty.

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

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

The description is very short and contains no filler words. However, it is under-specified to the point of being a fragment rather than an informative functional description, so conciseness alone is only average.

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, no annotations, and a 9-parameter input schema with zero required parameters. The description does not explain what the tool returns, how to request timezone names, or how it relates to sibling clock/time tools. An agent cannot reliably select or invoke this tool based on the provided information.

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 input schema already documents each parameter, including discard behavior. The description adds no parameter meaning beyond what the schema provides, so the baseline score of 3 applies.

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

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

The description is a noun phrase rather than a verb phrase: it names a resource ('Common IANA timezone names') and an intended use ('for clock calls'), but never states what the tool actually does with them—whether it returns, lists, validates, or converts. It also does not differentiate from sibling tools like timezone or utc-time.

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 about when to use this tool versus alternatives, and no exclusions are mentioned. The phrase 'for clock calls' weakly implies some clock-related context, but an agent cannot determine whether to choose this tool over timezone or utc-time.

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?

Without annotations, the description carries the full behavioral burden; it does disclose a non-obvious behavior: only group counts are returned, not full robots.txt content, and 'public' implies no auth. However, it still omits failure behavior, redirect handling, and which input is actually consumed by the fetch.

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

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

The description is a single ten-word sentence with no filler, and the key scoping phrase 'group counts only' is front-loaded. It earns full marks for conciseness even though other dimensions suffer from under-specification.

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

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

The context is complex: nine optional parameters, no annotations, no output schema, and several close siblings. The description states only the happy path and leaves the agent guessing how to identify the target robots.txt and what a 'group' is, so it is not complete enough for reliable 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?

Though all parameters have descriptions (100% coverage), those descriptions are generic and unrelated to robots.txt, mentioning ref, city, feed, JSON, and path. The description never says whether the robots.txt is selected by `url`, `host`, or `path`, so the high schema coverage does not rescue the mapping.

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 action ('Fetch'), a specific resource ('a public robots.txt'), and a precise return ('group counts only'), making the tool's job clear. It would earn a 5 with an explicit contrast to a sibling like web-fetch or fetch-status.

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 exclusion, and no reference to alternatives. Given nearby siblings such as web-fetch and fetch-status, an agent cannot tell when inspect-robots should be preferred over fetching the same URL with another tool.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does state that the key is discarded, which is a useful privacy/no-retention signal, but it does not describe the return value, failure behavior, or whether any network access occurs.

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 extremely concise and front-loaded: the purpose appears first, followed by the key behavioral note. Both sentences earn their place and there is no redundant filler.

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

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

For a simple validation tool, the description is too sparse. It does not specify which input parameter carries the Jira key, nor what the check returns (e.g., boolean, error, or normalized result). The lack of annotations and output schema makes this a meaningful 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?

The input schema documents each property in detail, but the description references a 'key' that does not appear as a schema property. An agent cannot tell which parameter holds the Jira key, so the description fails to bridge the gap between 'Jira issue key' and the actual input fields. The high schema coverage does not compensate for this missing mapping.

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 object: 'Check a Jira issue key shape.' This clearly distinguishes it from sibling tools like github-repo-shape and domain-shape. The additional note that the key is discarded also helps define 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?

The description gives no guidance on when to choose this tool over alternatives. It does not mention sibling tools or conditions for use, leaving the agent to infer applicability solely from the tool name and short phrase.

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

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

With no annotations, the description carries the disclosure burden. It does state two key behaviors: the result is an HTTP status and the body is discarded. However, it does not disclose whether the URL is actually fetched, redirect/timeout behavior, or what happens when non-URL parameters are supplied, so the transparency is minimal rather than 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 description is only two short sentences and front-loads the primary function and the important 'body discarded' caveat. It is appropriately sized, though the conciseness comes at the cost of not explaining the broader schema.

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 nine-parameter tool with no output schema and no annotations, two sentences describing only the URL use case is inadequate. The description does not explain whether the other parameters are alternative inputs, how the status maps to different value types, or how the tool relates to its name and sibling tools. An agent could not confidently use it for non-URL inputs.

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 itself adds no parameter-level meaning beyond singling out the URL case; all parameter semantics are already provided by the schema, so the description neither enhances nor harms this dimension.

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 outcome ('HTTP status') and a resource ('public library docs URL') and notes the body is discarded, which gives some clarity. However, it only covers the URL case while the schema exposes nine different optional parameters, and the 'public library docs' qualifier is narrower than the schema's generic 'HTTPS URL'. The tool's full scope is therefore unclear.

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 among the many sibling tools such as fetch-status, web-fetch, browser-url-ok, or normalize-url. The only implicit cue is 'Body discarded,' which hints that it is not for content retrieval, but no decision rule is provided.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Values discarded' does disclose a meaningful trait: values are not retained or validated. However, it does not mention error behavior, whether nested keys are counted, how the JSON object is supplied, or whether the operation has side effects.

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

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

Two short sentences with no filler. The core action and the key behavioral caveat ('Values discarded') are front-loaded and every word earns its place.

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

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

For a tool with nine optional parameters and no output schema, this description is under-specified. It does not explain which parameter carries the JSON object, what the return value looks like, how the count is structured, or why there are so many unrelated optional parameters. The schema covers parameters, but the overall calling context remains unclear.

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 nine parameters. The description adds no parameter-specific meaning, which lands at the baseline 3. The odd 'discarded after the shape check' notes in the schema are not reflected in the description.

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

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

The description clearly states a specific action ('Count keys') on a specific resource ('a JSON object'), and 'Values discarded' clarifies that it is not validation or transformation. It does not explicitly distinguish itself from sibling tools like validate-json, but the core purpose is unambiguous.

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

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

There is no guidance about when to use this tool versus alternatives, no exclusions, and no mention of related tools. The agent can only infer that it counts keys in a JSON object; it cannot tell when this should be chosen over validate-json or other siblings.

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

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

With no annotations, the description carries the disclosure burden. It clearly states that query and fragment are dropped and that the output is origin, host, and path, which is meaningful behavioral information. It does not discuss errors or exact response formatting, but for a simple URL transformation this is reasonably transparent.

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

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

The description is two short sentences with no wasted words. The primary output behavior is front-loaded, and the key caveat about query and fragment follows immediately.

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

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

The tool is conceptually simple and the description states its core output, but the surrounding context is more complex: nine optional parameters, no required parameters, no output schema, and no annotations. The description does not explain whether url is required, how the other parameters are treated, or what the full response shape is, so an agent gets the gist but not complete invocation guidance.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds a useful note about dropping query and fragment, but it does not clarify how the nine optional properties relate to the normalization behavior or resolve the ambiguity between the returned 'path' and the input 'path' property, which is described as a discarded file path.

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 action and resource: 'Return origin, host, and path for a URL.' It also adds a distinguishing behavior—query and fragment are dropped—so an agent can tell it apart from URL-checking or fetching siblings like browser-url-ok or web-fetch.

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 intended use is implied: use this tool when normalized URL components are needed. However, there is no explicit when-to-use versus when-not-to-use guidance, and no alternative tools are named, leaving the agent to infer selection from the tool name and 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?

With no annotations, the description carries the behavioral burden; it does disclose a key trait ('No browser is launched'), which prevents a likely misassumption from the Playwright name. It does not clarify whether the check performs a network request or local validation, what side effects exist, or what the response looks like, leaving a significant gap.

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

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

The description is two sentences with no filler, and the most important caveat (no browser launch) is included early. It is concise to the point of omitting useful context, so it is not a perfect 5.

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 nine optional parameters, no annotations, no output schema, and many URL-related siblings, this description is too thin. It does not tell the agent which parameter to supply, what result to expect, or how the openability check is performed without a browser, so confident invocation is not possible.

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 input schema fully documents all nine parameters, including discarded-value caveats. The prose description adds no parameter-level guidance, so baseline 3 is appropriate.

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

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

The description gives a concrete action ('Check whether a URL can be opened') and a clear resource (URL), and the second sentence differentiates it from browser-launching URL tools. The phrase 'can be opened' is somewhat ambiguous—HTTP reachability vs. syntactic validity—so it does not reach full specificity.

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

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

The use case is implied: call this when you need to determine whether a URL is openable without launching a browser. However, it never names alternatives such as browser-url-ok, fetch-status, or normalize-url, nor does it state when this tool should be avoided.

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

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

No annotations exist, so the description carries the whole behavioral burden. It usefully says 'Query discarded,' but it does not disclose the return value, how the nine parameters relate to the operation, or whether non-query parameters are ignored. That is a significant gap for a tool with this schema.

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

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

The description is two short sentences with the action verb front-loaded and no redundant restatement of the tool name. Every word earns its place.

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

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

This is a nine-parameter call with no annotations and no output schema. The definition omits the return value, the main input to populate, and the role of the other eight optional fields, so an agent cannot invoke it with full confidence.

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 every parameter; the baseline is therefore 3. The description adds no further parameter-to-usage mapping and leaves which field is the 'search query' to be inferred from the schema's query parameter.

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

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

The description names a clear operation and resource: count the characters in a search query. It is not a tautology and aligns with the tool name, though it does not explicitly distinguish this from sibling counting tools.

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

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

There is no guidance on when to use this tool rather than alternatives such as memory-key-count or hn-front-count, no prerequisites, and no exclusions. The use case is only implied by the verb 'count'.

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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It says nothing about side effects, input handling, return format, or what happens to the supplied parameters. The only behavioral hints ('discarded', 'normalize', 'validate') appear in the input schema, not in the description itself.

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?

At nine words, the description is terse, but this is under-specification rather than effective conciseness. It omits essential operational information and does not earn its brevity because every sentence should add value; here the only sentence merely restates the name.

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

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

With a seven-parameter schema, no annotations, and no output schema, a one-sentence noun phrase is completely inadequate. An agent cannot determine which parameter to pass, what the tool returns, or how it differs from sibling status/URL/validation tools.

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

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

The input schema provides detailed descriptions for every parameter, giving high schema coverage. The description adds no parameter-level meaning and does not connect the seven inputs to the purported 'catalog' purpose. Per the baseline rule for high schema coverage, a 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 is a noun phrase that essentially restates the tool name: 'Short catalog of common HTTP status codes.' There is no verb or explicit operation, so it fails to state what the tool actually does, especially given the 7 unrelated input parameters. It names a resource (HTTP status codes) but leaves the action and scope ambiguous.

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 siblings like fetch-status, normalize-url, or validate-json. The description provides no context, conditions, or exclusions to help an agent choose it correctly.

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

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

With no annotations, the description carries the burden of disclosing behavior. It does disclose one important trait: 'Prompt discarded,' indicating that the prompt is not used. However, it does not clarify whether the nine optional schema parameters are ignored, and the schema descriptions for url and host imply they might be used.

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 only two sentences and front-loads the main behavior. It is concise, though the phrase 'Prompt discarded' is abrupt and could be clearer by stating that all inputs are ignored.

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 nine optional parameters, no output schema, and no annotations, the description is too thin. It does not explain when to invoke the tool, what the three-step template contains, or whether the input schema is relevant at all.

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 even without parameter information in the tool description. The description adds no parameter-level meaning and leaves ambiguity about whether parameters like url or host are actually consumed.

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

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

The description clearly states a specific verb and resource: 'Return a three-step thinking template.' This is distinct from the sibling tools, which mostly check shapes, statuses, or counts. However, it does not explicitly differentiate itself from siblings or explain the purpose of the template.

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 about when to use this tool versus any of the many sibling tools. The description does not state conditions, alternatives, or exclusions, so an agent must infer usage from the tool name alone.

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

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

With no annotations, the description carries the burden of behavioral disclosure. 'Current time' strongly implies a read-only operation with no side effects, but the description does not address behavior for invalid or missing zone names, whether any of the other nine properties are ignored, or the 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 description is a single front-loaded sentence with no filler. Every word contributes to the core purpose, making it easy for an agent to parse quickly.

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 time-lookup tool, the description plus fully-covered schema is nearly sufficient, but the presence of nine optional parameters, no output schema, and no annotations leaves ambiguity about which parameter is required and what is returned for an invalid or omitted zone.

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 nine parameters. The phrase 'named IANA timezone' reinforces the zone parameter and helps disambiguate it from the other eight, but it adds no syntax, format, defaults, or error-handling detail beyond the schema.

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

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

The description states a specific operation—'Current time'—and a precise resource, 'a named IANA timezone,' which clearly separates it from siblings like utc-time (UTC only) and iana-zones (zone listing). Despite the absent title, an agent can understand exactly what the tool returns.

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

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

The description implies the use case: when a current time for a named IANA timezone is needed. However, it does not explicitly mention alternatives such as utc-time for UTC or iana-zones for zone names, nor any conditions or exclusions, leaving the choice between sibling tools to inference.

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 states the core behavior—returning the current UTC timestamp—but does not mention that all input parameters are effectively ignored or discarded, even though the schema descriptions hint at this. With no annotations, the description carries the burden and leaves this behavioral detail implicit.

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

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

The description is a single, front-loaded sentence with zero wasted words. It is appropriately sized for such a simple tool and communicates the essential result immediately.

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

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

Given the unexpectedly rich input schema with seven unrelated parameters and no output schema, a one-line description is insufficient. The description never explains that no arguments are needed for the timestamp or how the parameters relate to the tool, leaving the agent uncertain about how 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?

All seven input properties have descriptive schema text, so schema coverage is high and the baseline is 3. The tool description itself adds no parameter meaning and does not clarify that the timestamp does not depend on any of these parameters.

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

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

The description 'Current UTC timestamp' clearly states the tool's output: a UTC timestamp. It is unambiguous about the resource and the current time, though it lacks an explicit verb and does not differentiate from the sibling tool 'timezone'.

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

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

No guidance is given about when to use this tool versus alternatives like 'timezone' or 'iana-zones'. There are also no exclusions, prerequisites, or selection criteria, so the agent is left to infer usage solely from the purpose statement.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does note that the body is discarded, implying no persistence, but it does not state the return type, error behavior, or strictness of the validation, which is a significant gap for a tool that is solely about checking validity.

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

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

The description is two sentences with no redundant words and the core purpose is front-loaded. It loses a point because it omits the mapping between 'body' and the 'json' parameter, which would be a natural clarifying addition without hurting conciseness.

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

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

Given no annotations, no output schema, and a schema containing seven seemingly unrelated parameters, the description does not adequately define the input contract. It fails to specify which parameter is the body being validated or what the tool returns, making it insufficient for correct invocation.

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

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

The input schema provides detailed descriptions for all seven parameters, including 'json' as 'JSON text to validate; discarded after the check'. The description itself adds no parameter-level meaning, but since schema coverage is 100%, the baseline of 3 applies.

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

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

The description clearly states the tool checks whether a body is valid JSON, using a specific verb and resource, and is distinguishable from sibling shape-check tools. However, it does not explicitly name the 'json' parameter as the body, relying on the schema to make that connection.

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 guidance on when to use this tool versus alternatives like domain-shape or wiki-title-ok. There are no mentions of exclusions, alternatives, or ideal selection conditions, leaving the agent to infer usage entirely from the name and schema.

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?

There are no annotations, so the description carries the full burden of disclosing behavior. It mentions an external source (Open-Meteo) but fails to state the read-only nature, what happens with the many discarded inputs, the response shape, failure modes, or rate-limit implications.

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

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

The description is a single efficient sentence with no filler. The core message is front-loaded and every word earns its place.

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

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

With no annotations and no output schema, the one-sentence description leaves critical context missing: which parameters to supply, what the response contains, and how the tool behaves when multiple parameters are passed. The parameter count (9) makes this incompleteness more consequential.

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 itself adds no parameter semantics and even creates ambiguity by mentioning only 'city' while the schema exposes eight other optional properties, but the schema does individually describe each parameter.

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

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

The description states a clear resource ('a city'), a specific data source ('Open-Meteo'), and the returned value ('current temperature'), which also distinguishes it from siblings like geo-hint. It loses a point because it doesn't acknowledge the much broader input schema or clarify that non-city params appear irrelevant.

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

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

No guidance is given on when to prefer this tool over siblings or when not to use it. The only implicit signal is the name and the phrase 'for a city', but there are no explicit exclusions or alternatives.

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

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

With no annotations, the description carries the full transparency burden. It does disclose an important trait—the response body is discarded—and states the output is limited to status and content type. However, it does not mention redirects, authentication needs, error behavior, rate limits, or that many schema parameters are accepted and then discarded after validation.

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

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

The description is a single efficient sentence with no wasted words, and the key limitation ('Body discarded') is front-loaded. It is concise, though for a tool with this many parameters and sibling tools it is arguably too sparse to provide adequate structure.

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

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

Given no output schema, no annotations, nine optional parameters, and a large sibling set, the one-sentence description is not complete enough. It does not explain return format, which parameter to use, how parameters relate, error behavior, or how this tool differs from similar fetch/status tools.

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 schema already documents each parameter, including which values are discarded. The description adds little parameter-level meaning and fails to explain why nine unrelated optional parameters exist in a tool that seems to operate on a single public URL.

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

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

The description clearly identifies the tool's core behavior: it returns HTTP status and content type for a public URL and discards the body. It is specific about the resource and the output, but it does not explicitly differentiate this tool from sibling tools such as fetch-status or browser-url-ok.

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 guidance about when to use this tool versus the many sibling tools, nor any stated alternatives or exclusions beyond 'public URL.' The 'Body discarded' line implies the tool is not for retrieving body content, but this is not enough to guide selection among 27 sibling tools and 9 optional parameters.

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

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

No annotations are provided, so the description must disclose behavior. It only says the title is discarded, which is a weak privacy note and does not explain the call's result, whether it performs network access, whether it handles redirects, or what 'exists' means in practice.

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-loaded with the main purpose. The second sentence, 'Title discarded after the call', adds little and may confuse because no title parameter exists in the schema.

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

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

The tool is effectively unusable as documented: there is no output schema, no annotations, no usage context, and no title parameter to satisfy the stated purpose. An agent cannot determine what to send or what to expect 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?

The input schema contains eight string properties but no 'title' parameter, so the central concept of the description cannot be passed by the agent. The property descriptions are individually detailed but unrelated to the stated purpose, and the description does not map any parameter to the Wikipedia title.

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 purpose: check whether a Wikipedia title exists. This is a specific verb plus resource, and it is distinct from the sibling tools by naming Wikipedia. However, it does not mention any sibling or define what happens if the title does not exist.

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 like browser-url-ok, normalize-url, or file-path-ok. No exclusions or context are provided. The only implied usage is checking a Wikipedia title, but the description never says why or when that is preferable.

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