ISO country CX

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

Without annotations, the description carries the burden and does offer some transparency: it labels the gateway 'pay-per-call' and explicitly says task text is discarded. However, it does not disclose side effects, auth requirements, cost specifics, or what happens to each input beyond the schema's 'discarded' notes.

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 short sentences with the key purpose front-loaded and no filler. The parenthetical 'Monid' is unexplained jargon, which prevents a 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?

A seven-parameter tool with no output schema and no annotations needs more setup: which input is primary, how results are structured, and what triggers a hit. The description lists output themes but leaves an agent unable to construct a correct call with 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 baseline is 3 even without parameter details in the description. The description does not clarify which of the seven heterogeneous parameters should be supplied or how the gateway uses them, so it adds no 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 clear verb+object: find a public pay-per-call tool gateway (Monid), and enumerates resulting artifacts (CLI setup, how-it-works, skill file, remote MCP hops). It does not explicitly distinguish itself from sibling tools like web-fetch or normalize-url, though the 'gateway' resource is 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?

No when-to-use guidance or exclusions are provided. The description implies discovery of Monid, but an agent cannot tell from it when to choose agent-tool-index over any of the many sibling tools; 'Task text discarded' is an exclusion of usage, not a selection criterion.

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 are absent, so the description must carry the full burden of behavioral disclosure. It does disclose that no browser is launched, but it fails to explain what 'can be opened' means (e.g., HTTP request, DNS lookup, or syntactic validation). It also doesn't disclose that multiple input types are accepted or what side effects, if any, occur.

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 only two short sentences. It front-loads the primary purpose and adds the key qualifier 'No browser is launched.' However, the brevity comes at the cost of omitting necessary information about the tool's actual scope and the role of the other parameters.

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

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

Given the tool's complexity (seven heterogeneous parameters, no annotations, no output schema), the description is insufficient. It does not describe return values, the meaning of 'can be opened' for different parameter types, or how an agent should decide which parameter to provide. An agent cannot correctly invoke this tool for a non-URL input without additional 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?

All seven parameters have descriptions in the schema, so schema coverage is 100%. The description adds no additional semantics for the parameters, and by focusing only on URLs it underrepresents the actual parameter variety. The schema's own descriptions like 'discarded after the shape check' are the main source of meaning, so the description adds little 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 states a specific action ('check whether a URL can be opened') and adds the qualifier 'No browser is launched,' which helps distinguish it from sibling tools like playwright-url-ok. However, it doesn't mention the tool's broader scope: the input schema includes parameters such as ref, city, json, and path that are unrelated to URLs, leaving the agent uncertain whether this tool validates those shapes as well.

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 instructions on when to use this tool versus alternatives. It implies a contrast with playwright-url-ok by saying 'No browser is launched,' but it doesn't name the alternative or state conditions for selecting this tool. No guidance is provided for the non-URL parameters or related shape-check tools.

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

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

With no annotations, the description carries the full behavioral burden. It discloses only that the 'expression' is discarded, but says nothing about whether a numeric result is returned, whether evaluation errors surface, or what side effects occur. 'Evaluate' and 'discarded' are in tension, so the behavior is ambiguous.

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, but short is not concise here: at only two fragments it omits all operative details and provides no structure. The phrase 'Expression discarded' earns a place only by adding ambiguity, not clarity.

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?

Against a 9-parameter, no-annotation, no-output-schema tool, this description is grossly insufficient. An agent has no way to know what input to supply, what result to expect, or how this tool relates to the many sibling shape-check tools. It is not minimally usable.

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 has its own description, so the baseline is a 3, but the tool description introduces an 'expression' concept that does not map to any of the nine parameters. It gives no hint which parameter, if any, carries the arithmetic expression, and the schema descriptions actively point toward unrelated use cases.

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 ('Evaluate a+b style arithmetic') and a resource type, so it is not a tautology. But it becomes misleading when read against the input schema: no parameter accepts an arithmetic expression, and all nine parameters are described as URLs, cities, feeds, JSON text, etc. An agent cannot tell what 'calc-eval' actually operates on.

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 prefer this tool over any sibling such as validate-json, normalize-url, domain-shape, or search-query-len. There are no exclusions, prerequisites, or alternative route hints.

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 disclosure burden. It states a clear non-storage guarantee and that the operation returns derived URL data rather than content, but it does not disclose side effects, network dynamics, error behavior, or whether any fields are cached beyond the stated storage guarantee.

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 output front-loaded and a meaningful privacy qualifier in the second sentence. No filler or repetition; every clause 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 tool has zero required parameters, no output schema, and a 9-parameter schema with many ancillary fields, yet the description only addresses the URL and the return values. The named output values are useful, but the description does not explain how the extra schema parameters relate to invocation or how the result is structured, leaving a completeness 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 high (100%), so the schema already documents every parameter, including discard behavior for several fields. The description adds no per-parameter meaning beyond naming the URL as the input target, so it does not exceed the baseline.

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

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

The description names a specific action ('Return') and a concrete resource scope ('host, scheme, and HTTP status for a URL'), making the tool's core purpose unambiguous. It also adds the privacy trait 'Page content is not stored,' which distinguishes it from content-fetching siblings, though it does not name an alternative explicitly.

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

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

The intended use is implied: when an agent needs URL-level citation metadata (host, scheme, HTTP status) and must avoid storing page content. However, it gives no explicit guidance about when to prefer this tool over sibling tools such as normalize-url, fetch-status, or web-fetch, and no exclusions are 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?

The description adds a useful privacy behavior: 'No identifiers are retained.' However, with no annotations provided, the description bears the full burden of disclosing safety and side effects, and it does not state whether the operation is read-only, whether it makes network calls, or what happens to non-identifier data.

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—two sentences with no unnecessary wording. The privacy statement earns its place, though the first sentence's vagueness prevents a perfect score.

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 output schema, and no annotations, the description is incomplete. It does not explain what output the agent should expect, how to choose which parameter to supply, or how this tool relates to the many similar 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 no parameter-specific meaning beyond what the schema already provides; it only broadly reinforces the 'discarded' behavior already stated in each parameter 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 says 'Show how this request is classified' but never defines what 'classified' means or what 'compatibility' refers to. It does not distinguish itself from sibling shape/check tools such as domain-shape, normalize-url, or validate-json.

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 selection criteria, prerequisites, or any sibling tool that should be preferred in a given situation.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It only mentions label splitting and the absence of WHOIS/ownership data, but doesn't disclose return format, error behavior, network access, side effects, or whether the operation is read-only. The schema's 'discarded' hints are not present 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?

The description is a single efficient sentence with no fluff and the core action is front-loaded. However, it lacks any structured guidance, such as examples or parameter mapping, which would be more appropriate for a tool with nine parameters.

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, a one-sentence description is incomplete. It does not explain what the tool returns, which parameter to pass for hostname splitting, or how the remaining parameters should be treated.

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; each parameter already has a description. The description adds only a loose connection to the 'host' parameter by mentioning hostnames, but it doesn't clarify which of the nine optional fields is the intended input or how the others relate to splitting a hostname.

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: 'Split a hostname into labels', and adds a scoping constraint ('without WHOIS or ownership data'). However, it does not differentiate this tool from sibling shape-checking tools, and the broad 9-parameter schema (url, city, json, path, etc.) conflicts somewhat with the hostname-only focus.

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 github-repo-shape, figma-url-shape, or normalize-url. The description only says what the tool does, not the conditions or use cases that should lead an agent to select 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?

The description discloses the network method (HEAD) and the limited output (status only), which is useful. However, with no annotations, it omits other behavioral details an agent might need, such as redirect handling, timeout/error behavior, response format, and whether only the 'url' parameter is actually used while others are ignored.

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, tightly scoped sentence that front-loads the verb, target, and result. There is no filler, and every word contributes to the core behavior.

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 several overlapping sibling URL tools, one sentence is insufficient. Missing details include the primary parameter mapping, how to interpret the status result, behavior on non-2xx responses, and boundaries versus web-fetch/browser-url-ok.

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 description adds little beyond 'public URL', which implies the 'url' parameter is central, but it does not clarify how the nine optional parameters relate to the HEAD operation or which one should be supplied.

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 HTTP verb (HEAD), a clear target ('a public URL'), and the exact output ('return status only'). This distinguishes it from sibling tools like web-fetch, browser-url-ok, or normalize-url without needing to open their schemas.

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

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

The phrase 'public URL' and 'status only' clearly imply the use case: a lightweight reachability/status check without retrieving content. It does not explicitly name alternatives like web-fetch or browser-url-ok, but the context is clear enough for an agent to select it for a HEAD-style status 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses that the path is discarded, but does not state what is returned, whether a network call is made, how validation behaves, or what 'parse' produces. This is minimal and leaves significant ambiguity for an agent.

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

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

The description is very short and front-loaded, with no filler. Every sentence is terse and the main purpose is stated first. However, the second sentence is cryptic enough that it does not fully earn its place without elaboration.

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 no output schema and no annotations, yet the description does not explain the return value or the exact input contract among nine parameters. There is also no mention of how this relates to sibling shape-checking tools. This is insufficient for an agent to confidently select and invoke 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 the baseline is 3 even without parameter detail in the description. The schema descriptions themselves are generic and somewhat mismatched to the tool (e.g., 'url' says 'normalize or cite'), and the description does not clarify which parameter is actually used or how the other parameters are ignored. 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?

The description uses a specific verb ('Parse') and resource ('a Figma file URL'), which clearly distinguishes this tool from most siblings. It is concise and immediately identifies the domain. However, 'Path discarded' is ambiguous—it is unclear whether this refers to the URL path or the 'path' parameter.

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 normalize-url, browser-url-ok, or github-repo-shape. It does not state conditions, exclusions, or prerequisites. The only implicit cue is the 'figma' name in the tool name, which is not enough.

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 phrase 'No disk access' is a meaningful behavioral disclosure beyond the absent annotations, signaling a pure, side-effect-free shape check. 'Looks safe' also hints the check is syntactic rather than a real filesystem permission check, though return behavior and error handling are not described.

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

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

Two short sentences, front-loaded with the action and immediately followed by the key safety property. There is no filler; every token adds value.

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

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

For a tool with no output schema and no annotations, the description omits the return contract and the definition of 'safe,' and it does not acknowledge that the schema exposes nine parameters. However, the path-relevant parameter is documented in the schema, and the no-disk-access guarantee covers the most important side-effect concern.

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 met; each parameter, including path, already has its own description. The tool description adds no detail about how parameters map to the check, but the schema carries the necessary meaning.

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

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

The description states a concrete action ('Check') and a specific resource ('path'), and adds the qualifier 'looks safe' to define the success criterion. It is distinguishable from URL-oriented siblings by the explicit path focus, though it does not name an alternative.

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 browser-url-ok, normalize-url, or other shape-checking siblings. The only implied context is that paths are involved, so an agent must infer applicability.

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 must carry the behavioral disclosure burden. It only implies an external Open-Meteo call and does not describe whether the operation is read-only, how errors or rate limits behave, or that various schema parameters are ignored or 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 sentence with no filler and is easy to scan. It is concise, though arguably too terse 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?

With no annotations, no output schema, and nine optional parameters, the one-sentence description is insufficient for reliable invocation. It omits the return format, which parameter is the 'place', and how to handle multiple supplied parameters.

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 nine parameters are documented in the schema (100% coverage), so the baseline is 3. The description does add the idea that a 'place' is resolved to coordinates, but it does not explicitly connect that to the city parameter or clarify the roles of the other optional 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 concrete result (latitude and longitude) and a specific source (Open-Meteo), so an agent can identify this as a coordinate lookup. It does not explicitly map 'a place' to the city parameter or differentiate from siblings, but the core purpose is clear.

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

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

There is no guidance about when to use geo-hint instead of related siblings such as weather-hint, timezone, or validation tools. The description gives no contexts, exclusions, or alternative tool 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?

No annotations are provided, so the description carries the full burden. It discloses only that parsing happens, not what happens for malformed URLs, whether only the url parameter is used, or why many unrelated parameters exist. The term 'shape' in the name and the many 'discarded' schema fields are never explained.

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 single sentence is direct, front-loaded with the action, and contains no filler. It earns its place, even though the larger context requires more explanation elsewhere.

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, no output schema, and a nine-parameter schema full of unrelated optional fields, this short description is not enough. It does not state the return contract, error behavior for invalid GitHub URLs, or that irrelevant parameters are ignored, leaving too much to inference.

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%, giving a baseline of 3, but the description does not identify which parameter should receive the GitHub URL. The url parameter's own schema description says 'HTTPS URL to normalize or cite,' which does not match the description's parse-owner/repo purpose, and the other seven parameters are likely to mislead an agent.

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 specific: 'Parse owner and repo from a GitHub URL.' It names the verb, the resource, and the input domain, and it clearly distinguishes this tool from siblings like domain-shape or jira-key-shape without needing to read their schemas.

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 obvious use case—when an agent has a GitHub URL and wants the owner and repo—but it gives no explicit when-to-use versus alternatives, no prerequisites, and no mention of invalid or non-GitHub URLs.

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 must carry the full behavioral disclosure burden. 'Current' implies a live network fetch, but there is no mention of side effects, authentication, rate limits, or error behavior. 'Titles discarded' provides a small amount of output-shape transparency, but it is not enough to understand the tool's behavior.

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

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

The description is very short and front-loaded: the core purpose appears in the first sentence. The second sentence, 'Titles discarded,' is compact and adds some value by indicating a limitation. There is no filler or redundant content.

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

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

Given no output schema, no annotations, and nine loosely related optional parameters, the description is incomplete. It does not specify the return format, whether parameters are consumed or ignored, whether the tool performs a network request, or what happens on failure. An agent would need additional information to invoke it reliably.

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?

Parameter schema coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning beyond the schema; it does not explain which of the nine optional parameters are relevant to hn-front-count or whether they are ignored. The schema descriptions themselves are detailed, but the connection between them and this tool is unclear.

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: 'Count current Hacker News front-page stories.' This is a clear verb+object pair that distinguishes the tool from most sibling tools. However, it does not explicitly contrast with alternatives, and the phrase 'Titles discarded' is slightly ambiguous—it suggests the output excludes titles but could also be read as describing input handling.

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 guidance on when to use this tool versus alternatives. It implies use when a count of HN front-page stories is needed, and 'Titles discarded' hints that it should not be used when titles are required, but there are no clear conditions, 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?

With no annotations provided, the description carries the full behavioral disclosure burden, yet it never states whether the tool is read-only, what it returns, or how it behaves. The schema's 'discarded after' notes hint at some behavior, but the main description does not provide enough context.

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

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

The description is a single sentence with no filler and the key term 'IANA timezone names' appears first. It is appropriately short but so terse that it sacrifices operational clarity.

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 annotations, no output schema, and nine optional parameters, one sentence is insufficient. The description does not explain the call pattern, the expected return value, or how the optional parameters relate to the purpose, leaving an agent without enough information to invoke it 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?

All nine parameters are already described in the schema with 100% coverage, and the main description adds no parameter-level guidance. The baseline of 3 applies; the description does not reconcile why a timezone-name tool accepts URL, city, JSON, and file-path parameters, so it offers no extra semantic value.

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

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

The description identifies a resource (IANA timezone names) and an intended context (clock calls), so an agent can guess this tool supplies timezone names. However, it lacks a verb such as 'list' or 'return' and does not clearly state what the tool actually does or how it differs 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?

'for clock calls' offers a weak contextual hint that this tool is relevant when preparing time/clock operations, but there is no explicit when-to-use, when-not-to-use, or mention of alternatives. An agent must infer when to prefer this tool over siblings such as 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?

With no annotations, the description carries the full burden. It does disclose that only group counts are returned, but it does not describe error behavior, network expectations, or how the robots.txt content is fetched. The description also feels disconnected from the schema, where most parameters are described as discarded after shape checks.

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 one short, front-loaded sentence with no filler. It communicates the core action and output scope efficiently.

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 nine optional parameters, no annotations, and no output schema, this description is drastically incomplete. It omits which parameter carries the robots.txt URL, what inputs are acceptable, and what the returned counts mean, leaving an agent unable to reliably invoke 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 the baseline is 3, but the description introduces a 'robots.txt' resource without mapping it to any specific parameter. An agent cannot tell whether to use url, host, path, or some combination to specify the target, so the description adds confusion rather than clarity.

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 names a specific action ('Fetch a public robots.txt') and a constrained result ('return group counts only'), which distinguishes it from generic fetch tools like web-fetch. However, the connection to the provided input schema is unclear, since no parameter obviously identifies the robots.txt URL.

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

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

The description gives no indication of when to prefer this tool over siblings like web-fetch, fetch-status, or domain-shape. It also does not state what inputs are required or how the target robots.txt is selected.

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 disclosure burden but only offers 'Key discarded,' which hints at statelessness. It does not disclose what happens for valid vs. invalid keys, what the tool returns, or what shape rule is applied. This is minimal behavioral context for a validation 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?

The description is short, front-loaded, and both sentences carry information — the purpose and the discard behavior. However, the brevity crosses from concise into under-specified: it omits essential details such as the expected key format, the relevant parameter, and the return behavior.

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 loosely related optional parameters, zero annotations, no output schema, and a family of sibling shape-check tools, the description is far too thin. An agent cannot determine which parameter to populate, what shape constitutes a valid Jira key, or what the tool returns, so the definition is not complete enough to invoke correctly.

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

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

Schema coverage is 100% — all 9 parameters have descriptions — so the baseline is 3, but the description undermines this by referencing a 'Jira issue key' while no schema property is labeled as a Jira key. The parameters (ref, url, city, feed, host, json, path, zone, query) look like a generic shared template, and the tool description does not bridge the gap by identifying which parameter carries the key.

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 and resource: 'Check a Jira issue key shape.' It is immediately distinguishable from sibling shape-checkers like domain-shape, figma-url-shape, and github-repo-shape by the Jira domain. It falls short of 5 because it never defines what a valid Jira key shape actually is, and the first sentence largely restates the tool name.

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 the many sibling shape-checkers (github-repo-shape, wiki-title-ok, domain-shape). No context, prerequisites, or exclusion criteria are given, so an agent must infer usage solely 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?

With no annotations, the description itself carries the behavioral burden. It does disclose a key trait: only the HTTP status is useful and the response body is discarded, while 'public' weakly implies no auth. However, it omits edge behavior such as redirects, timeouts, or error handling.

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 main behavior is stated first and the body-discard note is a useful secondary detail. Every word carries meaning.

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

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

The tool has no annotations and no output schema, yet the description does not specify the output format, how to handle the nine optional params, or failure behavior. For a 9-parameter tool with no other structured guidance, this is insufficient.

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?

Although all nine parameters have schema descriptions, the description does not identify which parameter is the 'public library docs URL'. The schema calls url an URL to normalize or cite, not a status-check target, and optional URL-like fields such as feed and host create ambiguity, so the definition does not help an agent invoke it confidently.

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: return the HTTP status for a public library docs URL, and explicitly notes that the body is discarded. This is clear for a simple status-check tool, though it does not differentiate from generic sibling tools like fetch-status 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?

There is no guidance on when to choose this over the many status/URL siblings such as fetch-status, browser-url-ok, or normalize-url. No exclusions, prerequisites, or alternatives are mentioned, so an agent must guess the intended scope.

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 behavioral burden and does disclose that values are discarded. However, it does not clarify whether key counting is top-level only, how invalid input is handled, or what the return value looks like, leaving meaningful behavioral gaps.

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 concise: two short sentences with the core action front-loaded and no filler. It could be slightly more explicit about the input relationship, but it earns its length.

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 and no annotation coverage, and the description does not specify the return format or how the JSON object is supplied. Given the nine optional parameters with unrelated semantic descriptions, the ambiguity about what exactly is being counted makes the description incomplete for confident 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 coverage is 100%, so each parameter already has a description and the baseline is 3. The main description adds no per-parameter meaning and fails to explain how the parameters relate to 'a JSON object,' especially whether the count applies to the input object's keys or to the `json` 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 specific operation: 'Count keys in a JSON object' and adds a key behavioral detail, 'Values discarded.' This is clear and distinguishable from validation or length-counting tools, though it does not name sibling tools and leaves some ambiguity about whether the JSON object is the tool input itself or the `json` parameter.

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

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

The description provides no guidance on when to use this tool versus alternatives like validate-json or search-query-len. It states what the tool does but not when it should be selected, so an agent receives little 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?

With no annotations provided, the description must carry the behavioral disclosure burden. It does disclose that query and fragment are dropped, which is useful, but it fails to mention whether the URL parameter is required, what the output structure looks like, how invalid URLs are handled, or why the schema contains many unrelated parameters marked as '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 short and front-loaded, with no filler words. Both sentences earn their place by stating output and exclusions. It could benefit from one more sentence clarifying input requirements, but as written it is appropriately compact.

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

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

The tool has nine optional parameters, no output schema, no annotations, and a large sibling set, yet the description does not explain how to select or combine parameters. An agent cannot confidently determine whether to pass only 'url' or whether the other parameters are valid alternative uses. This is a significant completeness gap for a tool that appears simple on the surface.

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 itself documents all nine parameters with individual descriptions. The main description adds little beyond what the schema already says, and the parameter descriptions are inconsistent with the URL-normalization purpose (e.g., city, json, zone). The baseline of 3 applies because the schema carries the semantic load.

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 origin, host, and path for a URL', and adds a behavioral detail about dropping query and fragment. It is distinguishable from sibling URL-checking tools because it returns normalized components rather than checking availability or shape. However, the broad and unrelated optional parameters in the schema muddy the overall 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 explicit guidance on when to use this tool versus siblings like browser-url-ok, web-fetch, or figma-url-shape. It does not state prerequisites, required parameters, or when not to use it. The only hint is the implied use case of needing origin/host/path from a URL, which is not enough given the ambiguous optional 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?

With no annotations, the description carries the behavioral burden. It does disclose that no browser is launched, which is useful, but it does not state whether a network request is made, whether the check is read-only, or what the result looks like when a URL cannot be opened.

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 is stated first, and the clarifying behavioral note about no browser launch earns its place immediately after.

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 no output schema and no annotations, yet the description does not explain return semantics, failure behavior, or how the many schema properties relate to the URL check. The minimal wording leaves too much to inference for an agent to reliably select and invoke the tool.

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

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

The input schema already provides descriptions for all visible parameters, including notes about values being discarded, so schema coverage is high. The description adds no parameter-specific meaning, which is acceptable under the baseline but provides no extra disambiguation.

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 check on a URL with the verb 'check' and the resource 'URL', and 'No browser is launched' adds a meaningful qualifier. However, it does not explicitly distinguish this from the sibling tool 'browser-url-ok' or clarify what 'opened' means in terms of HTTP, DNS, or rendering.

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 instead of alternatives such as browser-url-ok, web-fetch, or fetch-status. The description does not mention conditions, exclusions, or scenarios where another sibling is preferred.

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 behavioral disclosure burden. 'Query discarded' usefully signals that the input is not persisted and suggests a side-effect-free operation. However, it does not disclose the return shape, how character count is defined, or whether only the `query` parameter is actually inspected.

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 filler: purpose first, then a behavioral caveat. It is appropriately front-loaded, though it may be too terse to fully support correct invocation.

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 output schema, and no annotations, the description is incomplete. It does not state which parameter is the search query, what the response looks like, or what happens when no query is supplied. The sibling context and schemas hint at broader shape-check behavior, but the description does not tie this together.

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 already has a semantic description; the tool description adds little beyond echoing 'search query.' The mapping to `query` is inferable but not explicitly stated, so the description does not elevate the schema baseline.

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

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

The description names a specific verb and resource: 'Count characters in a search query.' It matches the tool name and implies a distinct purpose from siblings like memory-key-count or hn-front-count. It is clear but does not explicitly differentiate itself from sibling 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, when not to use it, or which sibling is an alternative. With 9 optional schema parameters and many siblings, the description leaves the agent to infer both selection and invocation conditions.

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 only says 'short catalog,' which implies a read-only reference, but it does not explicitly state that the tool makes no network calls, ignores the supplied parameters, or returns a static list.

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 and useful scope qualifiers ('short,' 'common'). It earns its place, but it is on the edge of being too terse to be fully helpful.

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 annotations, the description leaves important context missing: the return format, the fact that no parameters are required, and the relationship between the catalog and the unrelated optional parameters. An agent could easily misinvoke this tool or confuse it with a live URL-status checker.

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 and the description need not repeat parameter meanings. However, the description also does not clarify why a status-code catalog accepts unrelated optional parameters such as url, city, and feed, leaving that semantic gap unaddressed.

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 resource—common HTTP status codes—and the tool's role as a short catalog. It is more than a tautology and distinguishes the tool from siblings like fetch-status, though it lacks an explicit action verb such as 'returns' or 'lists'.

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 such as fetch-status or web-fetch. The description does not state that no arguments are needed, nor does it mention any exclusions or preferred invocation context.

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

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

With no annotations, the description carries the full burden. It does disclose that the prompt is discarded and that the output is a generic template, suggesting a deterministic, non-mutating tool. However, it does not clarify whether the supplied parameters are used or ignored, and the contents of the template are unspecified.

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, front-loading the main action. It could include more usage context, but as written it is compact and each sentence contributes 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?

There is no annotations block and no output schema, so the description must fully support agent selection. With nine optional parameters and many sibling tools, this description is too thin: it leaves the trigger condition ambiguous and does not explain what the three-step template contains.

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 and the schema already documents each parameter individually. The tool description adds no parameter-level meaning and does not reconcile why parameters like url, city, or json are relevant to returning a thinking template.

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 a three-step thinking template.' It also adds a notable qualifier, 'Prompt discarded,' which clarifies the tool is not processing user content. However, it does not explicitly distinguish itself from sibling 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 versus alternatives. 'Prompt discarded' is a behavioral note, not a selection condition, and the description does not mention common triggers such as 'when asked for step-by-step reasoning' 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?

No annotations are provided, so the description carries the full burden. It communicates that the tool returns a current time but says nothing about output format, invalid timezone handling, network behavior, or whether any side effects occur; the schema hints at 'discarded' values but not in a timezone context.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. It is concise and readable, though it omits critical invocation detail that would make it truly complete.

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 schema having parameter descriptions, none support the described timezone behavior; there is no output schema and no annotations. The definition is not sufficient for an agent to select the right argument or understand the result, making it incomplete in a way that prevents correct use.

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 parameters are almost entirely unrelated to timezone lookup: ref, url, city, feed, host, json, path, and query describe a different validation/citation tool. The description mentions a 'named IANA timezone' but no schema property exists to supply that timezone, so the agent cannot correctly invoke the tool based on this definition.

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 time in a named IANA timezone' clearly states the tool's purpose and distinguishes it from siblings like utc-time and iana-zones. It is not a tautology, though it lacks an explicit verb and does not name alternatives.

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 when to use the tool: when the agent needs the current time expressed in a specific IANA timezone. However, it gives no explicit guidance about alternatives, exclusions, or when not to use this tool.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says what is returned and does not mention that the many input parameters are discarded or irrelevant, nor does it describe output format or 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 extremely short and front-loaded, but it under-specifies a tool that has a seven-property input schema. It is concise but not sufficiently informative.

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 unusual input schema with many seemingly unrelated parameters, this description is incomplete. An agent cannot tell which parameters are required, optional, or ignored, and the output format is not described. The description is adequate only for a trivial no-argument call.

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 descriptions are extensive, covering all seven parameters, so the baseline is 3. The description adds nothing about parameter meaning, but the schema already provides detailed guidance, including which parameters are discarded.

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

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

The description clearly states the tool returns the current UTC timestamp, a specific resource with a clear verb implied. However, it does not differentiate from sibling time-related tools like timezone or iana-zones.

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, and no mention of when not to use it. The intended use is implied but never explicit, leaving the agent to infer that it is for current 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?

With no annotations, the description carries the behavioral burden. It does disclose that the body is discarded, which signals no retention, but it does not specify the return shape, error behavior on invalid JSON, or whether other parameters are ignored.

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 purpose front-loaded and no filler. The discard note earns its place by adding behavioral context without verbosity.

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

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

A 9-parameter optional schema with no annotations and no output schema demands more than this. Missing are which parameter to pass, whether invalid JSON yields a boolean or an error, and whether the other optional fields are simply ignored.

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 `json` parameter is clearly documented as 'JSON text to validate', but the description never connects its generic 'body' to that parameter, and no parameters are required.

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

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

States a specific action ('Check whether ... valid JSON') and adds a distinguishing behavior ('The body is discarded'). This clearly separates it from sibling shape/URL checkers like domain-shape 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?

No guidance about when to use this tool versus the many sibling validation/shape tools, nor any exclusions or prerequisites. Usage context is only implied by the tool name and first sentence.

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 carry the behavioral disclosure burden. It only restates the basic function and mentions the Open-Meteo source, but does not disclose that most input schema parameters are ignored or discarded, nor what happens when the city is unknown or the request fails.

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 short sentence with no filler. Every word contributes to the core purpose, and it is immediately clear what the tool does.

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

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

The tool has nine optional parameters, no output schema, and no annotations, yet the description only covers the city-based weather use case. An agent cannot confidently determine which parameter to use, that other parameters are ignored, or what the response format will be.

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 parameters. The description adds only that 'city' and 'Open-Meteo' are relevant, but it does not clarify which of the nine optional parameters should be supplied, especially since none are required.

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

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

The description clearly states the tool returns the current temperature for a city via Open-Meteo, using a specific verb and resource. It does not explicitly distinguish itself from sibling tools like geo-hint, but the temperature and city scope make the core purpose understandable.

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 weather-hint versus alternatives such as geo-hint or web-fetch. The description does not mention any exclusions, prerequisites, or conditions that would help an agent choose this tool over 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 present, the description bears the full burden of behavioral disclosure. It does reveal the important trait that the body is discarded and only status/content-type are returned, which prevents an agent from expecting content. However, it does not address redirects, error behavior, or how the non-URL parameters (city, json, path, search) are handled, 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 two short sentences with no filler: the primary function is front-loaded and the body-discard constraint is added second. Every word earns its place, making it a model of concise, structured writing.

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 schema is rich with eight parameters, several of which (city, feed, json, path, search) are not mentioned in the description, and there is no output schema. The description covers only the URL case, so an agent cannot understand the full behavior or when this tool is appropriate relative to close 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?

The input schema already documents every parameter with descriptions, several noting that values are discarded after a shape check, so schema coverage is high. The description itself contributes little parameter-level meaning beyond reinforcing that the URL should be public, which is marginal against the schema baseline.

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

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

The description states a specific outcome ('HTTP status and content type') for a 'public URL' and explicitly notes the body is discarded, which distinguishes it from a full-content fetch. It is clear but does not explicitly relate to sibling tools like fetch-status, and it only covers the URL use case while the schema includes many other parameters.

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 such as fetch-status, nor does it state any exclusions or prerequisites. The intended use must be inferred entirely from the factual statement of what the tool does.

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. It discloses one behavioral trait: 'Title discarded after the call.' But this is vague and conflicts with the schema, and it does not disclose whether the check is read-only, performs network access, or 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 only two sentences and contains no obvious filler. However, the second sentence is ambiguous and could be omitted or clarified. Still, it earns credit for being short and front-loaded with the primary purpose.

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

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

The tool is simple in concept but the description and schema are disconnected. An agent cannot determine what parameter to pass for the Wikipedia title, what the return value looks like, or the semantics of the seven unrelated parameters. This is inadequate 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 lists seven string parameters (ref, url, city, feed, host, json, path), none of which represent a Wikipedia title. The description introduces a 'title' concept but does not map it to any schema property, making the parameters actively misleading. The schema descriptions are high-coverage but irrelevant to the stated 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 verb and resource: 'Check whether a Wikipedia title exists.' However, the input schema contains no parameter for a title, and the second sentence about the title being discarded adds confusion rather than clarity. The description does not differentiate from sibling shape-checking tools, and the mismatch between purpose and schema weakens 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 gives no guidance on when to use this tool versus alternatives. It does not mention any conditions, exclusions, or comparisons with sibling tools such as browser-url-ok or domain-shape. The agent is left to infer when 'wiki-title-ok' is the appropriate choice.

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