ISO country SR

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

With annotations all false, the description carries the burden, and it adds meaningful behavioral disclosures: the tool is 'pay-per-call' (a cost implication), it returns a defined set of artifacts, and it explicitly states that task text is discarded. This goes beyond the schema and gives an agent important expectations about side effects and data 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?

Three short, front-loaded sentences deliver purpose, outputs, and a key behavioral trait without wasted words. Every sentence earns its place, and no redundant elaboration clutters the description.

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

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

The description names the return artifacts, so the agent is not left guessing about outputs despite the absence of an output schema. It does not explain how the six diverse parameters map to the search, but the schema covers each parameter individually and the description is sufficient for a lookup-style 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 parameter semantics are already fully documented. The tool description does not add extra parameter-level meaning beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Find a public pay-per-call tool gateway (Monid).' It then lists concrete outputs (CLI setup, how-it-works, skill file, remote MCP hops), which clearly distinguishes it from the sibling utilities and leaves little ambiguity about what the tool does.

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

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

The intended use is implied by the instruction-like phrasing 'Find a public pay-per-call tool gateway,' but there is no explicit guidance on when to choose this tool over sibling tools, nor any stated exclusions or alternatives. The agent gets a purpose but not a decision rule.

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 browser is launched' is a genuinely useful behavioral disclosure because the tool name otherwise suggests browser activity. Yet with no annotations present, the description carries the full burden, and it does not state whether the check is network-based, purely syntactic, read-only, or whether any other side effects 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?

Two short sentences, front-loaded with the primary behavior and followed by the key caveat. There is no filler, repetition, or unnecessary detail.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, the description is too thin. It does not explain the return format, what 'can be opened' means, or how to select the correct parameter, leaving important operational details unresolved despite the schema covering parameter names.

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

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

The schema has 100% description coverage, so individual parameters are documented and the baseline is 3. The description itself only mentions 'URL' and adds no guidance about which of the nine parameters to pass, how they relate, or what happens if multiple are 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 states a clear action ('Check') on a clear resource ('a URL') and adds the important distinction that no browser is launched, which helps separate it from siblings like playwright-url-ok and web-fetch. It is slightly ambiguous whether 'can be opened' means syntactically valid, reachable, or browser-compatible, so it falls short of a 5.

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

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

The intended use is implied: use this tool to verify whether a URL can be opened without actually launching a browser. However, it gives no explicit when-to-use guidance, no alternatives, and no exclusions, so an agent must infer suitability from the tool name and brief description.

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

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

The only behavioral disclosure is 'Expression discarded', which is vague—it does not say whether evaluation results are returned, whether there are side effects, or what 'discarded' actually means. With no annotations provided, the description carries the full burden, and it does not meet that burden.

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 not verbose, but the brevity is under-specification rather than effective conciseness. Critical information about how the expression is supplied or what the tool returns is absent, so the few words present do not earn a higher 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?

With nine optional but largely unrelated parameters, no output schema, and no annotations, a two-clause description is completely inadequate. An agent cannot confidently call this tool without guessing which parameter represents the expression and what the response will look like.

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 a baseline of 3 is warranted, but the description references an 'expression' that does not exist as a schema parameter. It adds no mapping from the arithmetic expression to any of the nine parameters, making it difficult for an agent to know 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 specific operation ('Evaluate') and a specific resource ('a+b style arithmetic'), so an agent can identify this as an arithmetic-evaluation tool. It does not differentiate itself from siblings explicitly, but no sibling appears to perform arithmetic evaluation. The phrase 'Expression discarded' introduces some ambiguity about whether a result is actually returned.

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 any alternative, and no mention of exclusions or prerequisites. The phrase 'a+b style' hints at simple arithmetic scope, but the description never states what inputs are acceptable or how to choose among the many available sibling 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?

No annotations are provided, so the description carries the full behavioral disclosure burden. 'Public ... record' hints that the tool is read-only, but it does not state side effects, permissions, output format, or failure behavior. The schema-level notes, such as 'discarded after the shape check,' are not part of the tool description and are not connected to the tool's overall behavior.

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

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

The description is a single, short sentence with no filler, making it concise and easy to parse. For the limited content included, the structure is clean and front-loaded. However, the conciseness comes at the cost of substance, so it does not reach the highest rating.

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 optional parameters, 0 required parameters, no output schema, and no annotations, a one-line noun phrase is severely incomplete. An agent cannot determine what to pass in, what the tool returns, or when this tool should be called. The description needs at least an action verb and an explicit statement of the expected input and output.

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

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

Schema description coverage is 100%, with all 9 parameters individually documented, which earns the baseline score of 3. The tool description itself adds no semantic link between any parameter and the ISO 3166-1 record. While the schema covers parameter meanings, the description fails to clarify which parameter, if any, is the primary input.

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, 'Public ISO 3166-1 record for SR,' and lacks a verb, so it never says whether the tool returns, validates, cites, or looks up the record. It identifies an ISO standard and the code 'SR,' but the intended action is left entirely to inference. The name 'cc-sr' is cryptic and does not clarify the tool's role relative to siblings.

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

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

There is no guidance on when to use this tool versus alternatives like citation, fetch-status, validate-json, or normalize-url. The description does not state a use case, expected input, or context. An agent would be unable to decide whether this tool is relevant to the user's request.

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

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

With no annotations, the description must carry the behavioral burden; it does disclose a meaningful data-retention trait ('Page content is not stored') and implies a non-mutating URL check. It still omits explicit mention of the network request, failure behavior, or any rate-limiting/auth requirements.

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 the core output front-loaded and no filler. It is compact, though the minimal structure feels thin relative to the nine-parameter 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 and no output schema, the description leaves too much to inference: it does not describe the return shape, error handling, or when to choose this tool over fetch-status and normalize-url. The additional schema parameters are unexplained in context, so the agent cannot fully understand tool boundaries.

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; every parameter has an individual description. The tool description adds little parameter meaning and does not clarify which of the nine optional parameters are actually relevant to the citation check.

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: 'Return host, scheme, and HTTP status for a URL.' This is clear and not tautological, but it does not explicitly distinguish the tool from URL-focused siblings such as 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 alternatives or selection conditions are given. 'Page content is not stored' implies a privacy-oriented use, but the description never says when to prefer this tool over other URL/status 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 burden of behavioral disclosure. It adds a meaningful privacy guarantee ('No identifiers are retained'), but it does not disclose side effects, external calls, persistence, or what happens to the input beyond retention.

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 brief and front-loaded with the main purpose. Every sentence contributes, and there is no redundant filler, though the minimalism leaves some aspects under-specified.

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 parameters, no annotations, and no output schema, the description is too sparse. It does not explain what 'classified' means, what the output will look like, which parameters should be provided, or how this relates to sibling tools. The schema helps with individual parameters, but the overall tool behavior 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%, and each parameter is documented with meaningful context such as 'discarded after the shape check' or 'public weather hint.' The tool description itself adds no parameter-specific meaning, 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 clearly states a verb and object: 'Show how this request is classified.' It is specific enough to indicate the tool's core function, but it does not mention what classification system is used or how it differs from sibling tools like domain-shape or file-path-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 guidance about when to use this tool versus alternatives. No exclusions, prerequisites, or sibling routing are mentioned, so an agent must infer usage from the vague phrase 'this request.'

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

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

With no annotations, the description carries the transparency burden. It does state a meaningful limitation ('without WHOIS or ownership data'), suggesting a pure syntactic operation. It does not mention how invalid hostnames are handled, whether any network access occurs, or that the many other schema fields appear to be 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 filler. It immediately states the operation, the target resource, and an important scope boundary. 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?

The tool has a nine-parameter schema, no required parameters, no output schema, and no annotations. The description does not specify which parameter is the hostname input, what the return value looks like, or whether the other parameters are ignored. This leaves too much ambiguity for an agent to invoke the tool 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 the baseline is 3. The description maps naturally to the 'host' parameter, but it does not explain why eight other optional parameters exist or whether they should be ignored. The parameter descriptions themselves carry most of the semantic weight.

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 ('split') and resource ('a hostname'), and clearly scopes the output to labels while excluding WHOIS or ownership data. This differentiates the tool from sibling shape-check tools such as github-repo-shape or figma-url-shape.

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 you need hostname labels and explicitly do not need ownership data. However, it does not name alternatives or provide explicit criteria like 'use when...' or 'for ownership, use...', so the guidance is mostly implicit.

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 usefully discloses that the tool uses an HTTP HEAD request, targets public URLs only, and returns only the status, which also implies a safe, body-less operation. But it says nothing about redirects, error/status value semantics, or the fact that many non-URL parameters are accepted and discarded, so significant behavioral context is missing.

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 and the key behavior (HEAD, status only) appears immediately. It is concise to the point of under-specification, but as written it is efficiently structured.

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

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

Given nine optional parameters, no output schema, and no annotations, a one-sentence description covering only URL HEAD checks is not enough. An agent is left without an explanation of the other parameter types, how to combine them, or what the returned status means.

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

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

Schema description coverage is 100% and each parameter already has a meaningful description (e.g., 'discarded after the shape check'), so the schema carries the semantic load. The description adds only the 'public URL' context and does not clarify which of the nine parameters should be supplied or how they interact.

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 (HEAD), a resource (public URL), and a precise output (status only), so the URL use case is unambiguous. However, the input schema exposes nine varied string fields (ref, city, json, zone, query, etc.), which the description does not acknowledge, leaving the tool's actual scope 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?

No guidance is given about when to prefer fetch-status over sibling tools like web-fetch, browser-url-ok, or playwright-url-ok, nor any exclusions such as 'only when you need the status code, not the body.' The single sentence only implies a use case without helping an agent choose between 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 provided, the description carries the full behavioral burden. It does disclose that the input is parsed and the path is discarded, implying a non-destructive read-only operation. However, it does not state what the tool returns, how invalid URLs are handled, or whether any other side effects 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 concise and front-loaded with no wasted words. However, it is so terse that it under-specifies the tool's behavior and parameters, crossing from efficient conciseness into incompleteness.

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 the input schema includes nine loosely related parameters. The description does not tell the agent what output to expect, which parameter to provide, or how this tool relates to the many sibling URL/shape tools, leaving significant gaps.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds little beyond the schema: 'Path discarded' echoes the path parameter's existing schema description and does not clarify which parameter should hold the Figma 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 names a concrete action ('Parse') and a specific resource ('a Figma file URL'), and adds a meaningful qualifier ('Path discarded'). It is clear about the tool's core function, though it does not explicitly distinguish it from sibling URL/shape tools or state the exact output form.

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

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

The description provides no guidance on when to use this tool versus alternatives such as normalize-url, domain-shape, or file-path-ok. There is no mention of prerequisites, intended use cases, 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?

The description discloses one important behavioral trait: 'No disk access.' Since no annotations are provided, the description carries the burden of behavioral disclosure, and it does provide some safety-relevant context. However, it does not explain how safety is determined, whether the path is merely shape-checked, or what the tool returns.

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

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

Two short sentences with no filler. The core purpose comes first, and the critical 'No disk access' qualifier is included as a separate, earned sentence. Nothing here is wasted.

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

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

The tool has a surprisingly broad input schema with seven unrelated properties, no output schema, and no annotations. The description does not explain which parameter the agent should supply, what result format is returned, or how the operation differs from similar sibling checks. This leaves a significant 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?

The input schema already documents all seven parameters, so schema coverage is high. The description adds no parameter-specific meaning beyond reinforcing the path-related purpose. This meets the baseline for tools where the schema does the heavy lifting.

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

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

The description clearly states a specific verb and resource: 'Check whether a path looks safe.' It distinguishes the tool from URL- or domain-focused siblings by focusing on file paths. However, it does not explicitly differentiate itself from sibling tools or clarify what 'safe' means, so it stops short of a perfect score.

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

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

No explicit guidance is given about when to use this tool versus alternatives like browser-url-ok or domain-shape. The phrase 'No disk access' hints at a use case, but it is not framed as a selection criterion and no alternative tools are mentioned.

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 behavioral disclosure burden, but it only mentions the data source. It does not disclose that the tool likely performs an external network call, that non-relevant parameters are discarded, or what happens on invalid input.

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, which is efficient. However, it is under-specified given the tool's nine-parameter schema and lack of output schema, making the brevity feel more like omission than intentional 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?

The description does not explain how to select the correct parameter, what the output looks like beyond 'latitude and longitude', or any error/edge-case behavior. Given the high parameter count and no output schema, the tool definition leaves significant gaps for an agent trying 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?

Schema description coverage is 100%, so the baseline is 3. The description adds little beyond the schema; it does not explicitly connect 'a place' to the city parameter among the nine listed parameters, leaving the agent to determine which parameter is actually used for geocoding.

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 that the tool returns latitude and longitude for a place using Open-Meteo, which is a clear resource and source. However, it lacks an explicit verb and does not differentiate the tool from siblings like weather-hint that might also involve place-based data.

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

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

There is no guidance about when to use this tool versus alternatives such as weather-hint or timezone. No prerequisites, exclusions, or selection criteria are provided, so the agent is left 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?

With no annotations present, the description carries full responsibility for behavioral disclosure, but it only says 'parse'. It does not state that the operation is local and non-network, what happens for non-GitHub URLs, how errors are surfaced, or that many of the accepted parameters are ignored/discarded; the schema's per-parameter notes partly cover this, but the description itself does not.

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 clean sentence with no filler, front-loading the operative verb and resource. It is appropriately terse for the core purpose, though the lack of any mention of the broader shape-check behavior makes it minimally concise rather than exemplary.

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 parse tool this is nearly sufficient: the agent can infer that it should supply a GitHub URL in `url` and expect owner/repo. But there is no output schema and no annotation safety net, and the large list of unrelated-looking optional parameters is unexplained by the description, so an agent cannot fully predict return format or failure behavior.

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

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

Schema description coverage is 100%, so the baseline is 3; the description does add the useful hint that the `url` parameter should be a GitHub URL and that owner/repo are the extracted result. It does not explain why the other optional parameters exist or whether they affect the result, but the schema already documents each one.

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 ('parse'), a specific resource ('a GitHub URL'), and a concrete result ('owner and repo'), making the tool's core function immediately clear and distinguishing it from sibling shape tools like `figma-url-shape` or `jira-key-shape`. It does not explicitly frame the operation as a local shape check, 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?

The description gives a clear implied use case: whenever an agent has a GitHub URL and needs owner/repo extraction. However, it offers no explicit exclusions, no mention of when another sibling tool should be used instead, and no statement about whether this should precede or substitute for URL validation or fetching.

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. 'Count current' signals a read-only snapshot, and 'Titles discarded' reveals a result-shaping behavior beyond the name. However, it does not disclose the return format, network dependency, failure behavior, or whether the many optional parameters are ignored, 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 main action is front-loaded, and the extra 'Titles discarded' detail earns its place by setting expectations about the result. It is appropriately minimal for the stated operation.

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 description is too sparse for a tool with 9 optional parameters, no output schema, and no annotations. The agent is left unsure whether any parameters affect the count, what the return value looks like, or why parameters like city, json, zone, and path appear in the schema. The sibling context only increases the need for clearer positioning.

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 adds no parameter-specific meaning and does not explain how the nine optional parameters relate to counting Hacker News stories. The schema descriptions cover each parameter individually, but the description offers no additional semantic context.

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 current Hacker News front-page stories.' It also clarifies that titles are discarded, which sharpens what the tool does and does not return. It does not explicitly distinguish itself from sibling fetch/count tools, 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?

No guidance is given about when to use this tool versus alternatives like web-fetch, fetch-status, or other count-oriented siblings. The description states what the tool does but not when it should be preferred or when it should be avoided. The agent is left to infer usage 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not mention that most parameters are discarded, that the tool only returns common timezone names, or what the output format is. For a tool with no annotation coverage, this is 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 a single short sentence with no wasted words. However, the brevity comes at the cost of substance—it is concise but not informationally rich.

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 mostly unrelated parameters, no annotations, no output schema, and no usage guidance, the description is not complete enough for an agent to invoke the tool confidently. It fails to explain what the tool returns, how parameters are used, or why a mix of 'ref', 'url', 'city', 'feed', 'host', 'json', 'path', 'zone', and 'query' are relevant to IANA timezone names.

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-level detail, but the schema already documents all 9 parameters, including explicit notes that values like 'ref', 'city', and 'json' are discarded. The description does not need to compensate.

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 'Common IANA timezone names for clock calls' conveys that the tool relates to IANA timezone names in the context of clock calls, but it does not state what the tool actually does (e.g., validate, list, return). It is not a tautology, but it is vague and fails to distinguish itself from siblings 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?

The description offers minimal context ('for clock calls') but gives no explicit guidance on when to use this tool versus alternatives. It does not mention any exclusions, prerequisites, or conditions that would help an agent choose between this and sibling 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 behavioral disclosure burden. It does disclose that the operation is a public read ('public robots.txt') and that output is intentionally limited ('group counts only'), but it does not describe failure behavior, rate limits, or whether the full robots.txt is ever returned.

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

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

A single front-loaded sentence with no filler. It states the action, target, and output limit 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 9 parameters, no required fields, no output schema, and a one-line description, the definition is not complete enough for an agent to invoke it confidently. It does not define 'group counts', specify which parameter to set, or describe the return shape.

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

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

The schema has 9 optional parameters with 100% description coverage, but the descriptions are generic and geared toward many tools (e.g., 'HTTPS URL to normalize or cite', 'City name for a public weather hint'). The tool description never tells the agent which parameter supplies the robots.txt URL, so parameter selection remains ambiguous.

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 ('Fetch'), a concrete resource ('a public robots.txt'), and the exact output scope ('return group counts only'), which makes the tool's purpose unmistakable and distinguishes it from generic fetch tools 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?

Usage is implied by the tool name and description: use it when you need robots.txt group counts. However, it does not state when not to use it or point to any alternative among the many sibling tools, so the guidance is minimal.

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 reveals only that the key is 'discarded' after checking, but does not state what constitutes a valid shape, whether validation is local or networked, what it returns on success or failure, or any 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 the main action, and the 'Key discarded' note is a genuine behavioral detail. But for a 9-parameter tool with no output schema, this terseness crosses into 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?

Given no annotations, no output schema, nine optional parameters, and no connection between the description and the schema, an agent cannot determine what to pass or what result to expect. The tool is effectively underspecified 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?

The schema covers 100% of parameters, but none of the nine properties (ref, url, city, feed, host, json, path, zone, query) is named or described as a Jira issue key. The description references a 'key' yet does not say which parameter receives it, leaving invocation ambiguous despite high schema coverage.

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 ('Check') and names the exact resource ('a Jira issue key shape'), which distinguishes it from sibling shape tools like domain-shape or figma-url-shape. However, it is largely a restatement of the tool name with no additional elaboration, 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?

There is no guidance on when to use this tool versus the many sibling shape/check tools, no prerequisites, and no alternatives. The only usage signal is implied by the phrase 'Jira issue key shape'.

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 does disclose a meaningful behavioral trait: only the HTTP status is provided and the body is discarded. However, since no annotations are present, it carries the full burden, and it omits other useful details such as the HTTP method used, timeout behavior, authentication needs, or what happens when multiple parameters are supplied.

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 wasted words; the core operation and the body-discard behavior are front-loaded. The description is compact without becoming tautological.

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, and no output schema, this description is too thin. An agent cannot tell which parameter to populate, whether the other parameters are ignored, or what the exact output shape is beyond 'HTTP status.' More context is needed 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?

All nine parameters already have descriptive schema entries, so the baseline is 3. The description adds no parameter-level detail and notably fails to state which of the optional parameters is the relevant one for a library docs URL check, but the schema itself is sufficiently documented.

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 conveys that the tool returns/checks the HTTP status of a public library docs URL and discards the response body. It is specific to library docs, which helps separate it from generic HTTP tools, though it does not explicitly name any sibling tool or use a clear verb like 'check' or 'return'.

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

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

The phrase 'for a public library docs URL' implies the intended use case, but there is no explicit guidance about when to choose this tool over siblings like fetch-status, browser-url-ok, or web-fetch. No exclusion criteria or alternative-routing advice is provided.

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

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

With no annotations, the description carries the behavioral burden. It does disclose that values are discarded, which is useful, but it does not describe how invalid JSON is handled, whether the count is top-level or nested, or what the return value looks like.

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

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

Two short sentences deliver the core behavior and the important discarded-values caveat without filler. The most relevant information is front-loaded.

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

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

The description is thin for a tool with no annotations, no output schema, and nine optional parameters. It leaves unclear which parameter to pass, what the exact return value is, and how malformed JSON is 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 coverage is 100%, so the baseline is 3. The description adds no parameter-level detail and does not explicitly identify which parameter supplies the JSON object, but the schema already documents all nine parameters and their meanings.

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 keys in a JSON object' and adds that values are discarded. This is clear and non-tautological, though it does not explicitly call out how it differs from siblings like validate-json or domain-shape.

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

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

Usage is implied: use the tool when only the number of keys in a JSON object matters and the values are irrelevant. However, there is no explicit when-to-use or when-not-to-use guidance, and no alternatives are named.

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

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

The description adds a meaningful behavioral detail by stating that query and fragment are dropped, and 'Return' implies a pure, read-only operation. However, with no annotations provided, it does not fully carry the burden: it omits error behavior, network side effects, and what happens with the many non-URL schema parameters.

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 action is stated first, and the exclusions follow immediately, 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?

With nine parameters, no annotations, and no output schema, the description is not complete enough. It does not define the return structure (object vs string), behavior on invalid URLs, or the relationship of the unrelated parameters to URL normalization, so an agent would be guessing about the response shape and tool scope.

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

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

Schema description coverage is 100%, so the baseline is 3; the description does add a useful behavioral note for 'url' by saying query and fragment are dropped. But it provides no semantic guidance for the other eight parameters, leaving the agent puzzled about why ref, city, feed, json, path, timezone, and query are accepted by a normalize-url tool.

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

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

The description uses a specific verb ('Return'), names the resource ('URL'), and lists the outputs ('origin, host, and path'), which clearly states what the tool does and broadly differentiates it from sibling URL-checking tools. However, the schema exposes nine unrelated optional parameters such as city, feed, json, and timezone, and the description does not reconcile that mismatch.

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 a clear usage context: normalize a URL and extract origin, host, and path while dropping query and fragment. It does not provide explicit guidance on when to prefer this tool over siblings like browser-url-ok, playwright-url-ok, or web-fetch, nor any 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?

There are no annotations, so the description carries the full burden of explaining behavior, but it only says 'Query text discarded' and lists returned content. It does not explain that the schema parameters appear to be shape checks or discarded inputs, nor does it disclose side effects, output shape, or response 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 three terse sentences with no filler, front-loading the purpose, then the returned content, then the query caveat. 'Living' and 'Ploid' are slightly unexplained, but the size and ordering are efficient.

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

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

With nine optional parameters, no output schema, and no behavioral annotations, this description is not complete enough for an agent to know what arguments to pass or what the returned docs/API/hops actually look like. The query-discarded note helps, but the overall invocation pattern is 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?

The input schema already documents all nine parameters with 100% coverage, so the description does not need to add much per-parameter detail. The tool-level description adds little beyond the query-discarded caveat already present in the schema, making the baseline 3 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 begins with a specific verb and object: 'Find a living people-search index (Ploid).' It lists the returns ('CLI setup, docs, API, and remote MCP hops'), which gives the agent a clear sense of what the tool provides. It does not explicitly contrast with sibling index/lookup tools, so it falls just short of full differentiation.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives such as agent-tool-index or lib-docs-hint. The 'Query text discarded' caveat warns about an input, but it does not state invocation context, preconditions, or when not to use the 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?

The description discloses one non-obvious behavior ('No browser is launched') that is valuable given the Playwright name. However, with no annotations it doesn't disclose whether a network request is made, what counts as 'openable,' or whether it returns a boolean/status, leaving a partial behavioral picture.

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, both informative, with the core action first and the key caveat second. No wasted words.

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, a 7-parameter tool needs more than 'URL can be opened' to be complete. The description omits return behavior, success criteria, network side effects, and the role of the extra parameters, leaving too many gaps 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?

The seven parameters are individually described in the schema, but the description doesn't indicate which parameter is the URL to check, and several schema descriptions ('normalize or cite', 'discarded after the shape check') are misaligned with the 'can be opened' purpose. High schema coverage doesn't compensate because the meaning is ambiguous and some fields appear unrelated.

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

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

The description states the operation ('Check whether a URL can be opened') with a specific verb and resource. The added 'No browser is launched' hints at a lightweight check, though it doesn't explicitly name a sibling like 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?

The phrase 'No browser is launched' gives a clear selection signal — use this when you don't want a browser session. However, it doesn't explicitly say when to use browser-url-ok, fetch-status, or normalize-url, nor state exclusions. The usage context is implied rather than 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 behavioral burden. It does disclose one meaningful behavior: 'Query discarded' indicates the input is not retained. However, it does not state that other parameters are ignored, what the return value looks like, or whether any side effects occur beyond 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?

Two short sentences with the core action front-loaded. 'Query discarded' is a compact, non-redundant behavioral detail. There is no filler or repetition.

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

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

For a simple length-check tool, the description is nearly adequate, but it leaves key invocation details implicit: with 9 optional parameters and none required, it never says to pass the `query` parameter, nor does it explicitly state that the result is an integer character count. The schema partially compensates, but the description alone is not fully complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning beyond the schema; the query property already identifies 'Search text; discarded after the length check.' No additional semantic value is provided.

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 ('Count characters') and a clear resource ('a search query'), matching the tool name. It does not explicitly distinguish from sibling counting tools like memory-key-count or hn-front-count, 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?

There is no guidance on when to use this tool versus alternative tools, no exclusions, and no mention of which sibling tools it complements or replaces. The intended use is implied by the name and the query parameter, but never stated explicitly.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state the return format, whether the data is static or remote, whether there are side effects, or how the supplied ref, url, city, feed, host, json, path, zone, and query parameters are used. 'Short catalog' hints at read-only content but does not meaningfully disclose 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 has no filler, but this is under-specification rather than disciplined conciseness. A single noun phrase that does not convey operation, parameter selection, or output cannot earn high marks for structure. Brevity here comes at the expense of usefulness.

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 nine optional parameters, no output schema, no annotations, and a large set of sibling tools, the definition is critically incomplete. An agent cannot determine which parameters to supply, what the tool will return, or how a 'catalog of HTTP status codes' relates to the input fields. The description is far too thin for the surrounding complexity.

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

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

Schema description coverage is 100%, so the schema already documents each parameter individually, which sets the baseline at 3. The tool description adds no parameter-level information of its own. However, the schema descriptions do not connect the parameters to HTTP status codes, so the overall parameter semantics remain confusing despite the high schema coverage.

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 essentially a noun phrase that restates the tool name: status-catalog is 'a catalog of common HTTP status codes.' It adds the qualifier 'HTTP' and 'common,' but it provides no verb, no operation, and no explanation of how the nine unrelated-looking parameters relate to the catalog. This is bordering on tautology rather than a clear statement of what the tool does.

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

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

The description gives no guidance on when to use this tool versus siblings such as fetch-status, web-fetch, normalize-url, or validate-json. There are no prerequisites, exclusions, or alternative recommendations. The only implied use is 'consult a catalog of status codes,' which is too thin for an agent choosing among many sibling 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 behavioral disclosure burden. It explicitly says 'Prompt discarded,' which is a key non-obvious behavior: the tool ignores the user input and returns a template. However, it does not explicitly state that all nine structured parameters are ignored, leaving some ambiguity about the discard scope.

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, containing only two short clauses: the output type and the input-discarding behavior. Every word earns its place, and there is no filler or redundant information. It is well-structured and front-loaded for quick comprehension.

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 description does not explain what the three-step thinking template actually contains or how an agent should use it, which is essential for deciding whether to call this tool. It also does not clarify that all structured input parameters are ignored, and with no output schema or annotations, the agent has insufficient context. The heavy reliance on the input schema's parameter descriptions makes the definition 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?

The schema has 100% description coverage, so the baseline is 3. The description's 'Prompt discarded' provides a global hint that parameters are irrelevant, but the per-parameter meanings are already fully described in the schema with 'discarded after...' remarks. Thus the description adds little semantic value 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 verb and resource: 'Return a three-step thinking template.' It clearly distinguishes this tool from the validation and fetching siblings, as it is not a checker or fetcher. The 'Prompt discarded' clause reinforces that it is a fixed-output tool, making the core purpose unmistakable.

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. The description never mentions conditions, exclusions, or alternative sibling tools. An agent is left to infer the appropriate context from the name and vague wording.

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, but it only states the core lookup and says nothing about output format, handling of invalid zone names, or side effects. The schema's many 'discarded' parameters actually obscure what the tool does with its input.

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 seven-word sentence with no filler or redundant schema repetition. It is appropriately concise for stating the tool's 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?

Despite the simple concept, the definition is not complete enough to invoke reliably: it lacks an output schema, annotations, and any indication of which parameter should receive the IANA zone. This is a critical gap because all visible schema properties are described as unrelated utilities or discarded values.

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

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

Although schema descriptions cover 100% of the visible properties, none of them is described as an IANA timezone; city is explicitly a weather hint that is discarded. The description adds no mapping between 'named IANA timezone' and a parameter, and with additionalProperties false an agent cannot supply a timezone field.

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 operation (return current time) and the resource (a named IANA timezone). It distinguishes this tool from siblings like utc-time and iana-zones without ambiguity.

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

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

The phrase 'named IANA timezone' implies the tool is for time lookups when a zone name is available, but there is no explicit when-to-use or when-not-to-use statement. It does not mention alternatives such as utc-time for UTC or iana-zones for listings, so guidance is only implied.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not state that the tool is side-effect free, that all nine parameters are optional and effectively ignored, or that no network or authentication is required. The schema parameter descriptions hint at discarding, but the tool description itself is silent.

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 phrase with no filler and the core meaning is front-loaded. It is appropriately concise, though it approaches under-specification rather than achieving the clarity of a well-structured complete sentence.

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

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

Given nine optional, seemingly unrelated parameters and no output schema, a one-phrase description is insufficient. It does not explain why the parameters exist, how to invoke the tool, or what the response format looks like. The schema partially compensates, but the description alone leaves important gaps.

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

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

Schema description coverage is 100%, so each parameter already has a description in the schema, including notes like 'discarded after the shape check'. The tool description adds no parameter information, but the high schema coverage leaves the baseline at 3.

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

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

The description names the resource ('UTC timestamp') and its scope ('current'), making the tool's output identifiable. It is distinguishable from siblings like timezone and iana-zones, but it lacks an explicit verb such as 'returns' or 'gets', so it is slightly less direct than a full action statement.

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

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

No guidance is given about when to use this tool versus alternatives like timezone, iana-zones, or calc-eval. There is no mention of exclusions, prerequisites, or typical use cases, forcing the agent to infer applicability solely from the tool 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?

There are no annotations, so the description carries the burden. 'The body is discarded' adds a useful behavioral guarantee that the input is not retained and the operation is non-mutating, but it does not disclose what the tool returns for valid versus invalid JSON or whether it throws.

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: two short sentences with the action first and a meaningful side-effect note second. There is no filler or redundant explanation.

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 should state what the agent can expect back from the check and which parameter carries the body. It only says the body is discarded, leaving return semantics and the role of the many other parameters unexplained.

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 seven properties, so the baseline is met. The tool description adds little parameter meaning beyond mentioning a discarded 'body' and does not clarify how 'body' maps to the `json` parameter or why fields like `city`, `host`, and `feed` appear.

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 and resource: 'Check whether a body is valid JSON.' This distinguishes the tool from URL, file, and domain shape checkers by focusing on JSON syntax. However, 'body' is slightly ambiguous and the description does not explicitly tie it to 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?

Usage is implied: use this tool when you need to verify whether some text is valid JSON. There is no explicit when-not-to-use guidance or reference to sibling alternatives such as file-path-ok or domain-shape, so an agent gets only implicit 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 of behavioral disclosure. It only says 'via Open-Meteo,' hinting at an external dependency, but does not disclose that most schema parameters are discarded, what the return format is, whether the call is read-only, or any rate limits or error behavior. The schema notes 'discarded' for many parameters, but the main description does not.

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 worded sentence with no redundant content. It front-loads the core function and data source, making it easy to scan. Every word contributes to the agent's understanding.

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 straightforward temperature lookup, the description is sufficient to select the tool, but it leaves gaps: no units, no output format, no mention of the eight non-city parameters or their ignored status. The schema partially fills these gaps, but the overall package relies heavily on the schema for full 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 schema already documents each parameter, including 'City name for a public weather hint'. The description adds little beyond the Open-Meteo data source, which is not parameter-specific. It does not meaningfully enrich the meaning of the parameters beyond what is already in the schema.

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

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

The description clearly states a specific function: returning the current temperature for a city, and identifies the data source (Open-Meteo). This makes the primary purpose easy to identify and distinguishes it from sibling hint tools. However, the schema includes eight additional parameters with no mention in the description, which could confuse an agent about whether the tool serves broader purposes.

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

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

The description implies the tool should be used when a current city temperature is needed, but it gives no explicit guidance on when to prefer it over similar siblings like geo-hint. There are no exclusions, alternatives, or conditions mentioned, leaving usage inference to the agent.

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 usefully discloses that the body is discarded, so callers know not to expect page content. However, it does not mention redirects, timeouts, error behavior, response format details, or whether any side effects 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?

Two short sentences with no filler. The core behavior and the important body-discarded limitation are front-loaded, making the description easy to scan and act on.

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 description is minimally sufficient for a simple fetch-check tool, and it states the return scope ('HTTP status and content type') even without an output schema. Still, the lack of annotation coverage, the large optional parameter set, and the presence of many similar siblings leave gaps around parameter selection and error/edge-case behavior.

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

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

Schema coverage is 100%, so the parameter descriptions already document each field. The tool description adds only 'public URL' context and does not need to repeat parameter details, but it also does not clarify that url is the primary input among the nine 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 clearly states the tool returns HTTP status and content type for a public URL and explicitly notes that the body is discarded. This makes the core purpose evident, though it does not explicitly distinguish it from siblings like 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?

The phrase 'public URL' gives a mild usage constraint, but there is no guidance about when to prefer this tool over the many URL-related siblings, nor any exclusions or alternative routing. The agent is left to infer which sibling matches the task.

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 one behavioral note, 'Title discarded after the call,' which is useful but insufficient. It does not disclose the return value, error behavior, or whether a network request is made, and the schema's parameter descriptions repeatedly mention discarding inputs, which creates confusion about what the tool actually does with a title.

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, with the purpose in the first sentence and a side-effect note in the second. It is front-loaded and contains no filler, but it sacrifices necessary information 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?

Given no annotations, no output schema, and a mismatched input schema, the description is severely incomplete. It omits the crucial mapping between the title concept and the actual parameters, as well as any detail about expected output or failure modes, leaving an agent with no reliable way to 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 description never identifies which schema property corresponds to the Wikipedia title, and the schema contains no 'title' parameter—instead listing ref, url, city, feed, host, json, and path with unrelated descriptions. The agent cannot determine how to provide the required input, making the tool effectively uncallable from the description and schema alone.

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 whether a Wikipedia title exists.' It conveys the primary purpose unambiguously, but it does not differentiate itself from sibling '-ok' tools like browser-url-ok or figma-url-shape—its scope is implied rather than explicitly contrasted.

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 this tool versus siblings such as fetch-status or validate-json. There is no mention of prerequisites, context, or exclusions, leaving the agent to infer appropriate usage from the name alone.

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