ISO country EH

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

No annotations are provided, so the description carries the behavioral disclosure burden. It does reveal that task text is discarded and lists what the tool returns, which is useful. However, it does not clarify side effects such as network calls, authentication requirements, cost implications beyond the 'pay-per-call' hint, or whether the returned content is static or dynamically fetched.

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 compact and front-loads the core purpose and return contents. Each sentence adds information and there is no filler, though the terseness leaves some important gaps.

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

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

Given 9 optional parameters, no output schema, and no annotations, the description is under-specified. It lists outputs but does not explain how to invoke the tool, what input shape is expected, or what the returned structure looks like, leaving an agent to guess how to choose or fill parameters.

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

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

Schema description coverage is 100%, so the schema already documents each of the 9 parameters. The description adds no parameter-level meaning of its own and does not explain which parameters matter for 'finding' the gateway, so it neither improves nor degrades on the schema baseline.

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

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

The description states a specific action ('Find') and a specific resource ('a public pay-per-call tool gateway (Monid)'), and lists concrete return items: CLI setup, how-it-works, skill file, and remote MCP hops. This makes the tool's basic function understandable, though 'Monid' and 'tool gateway' are somewhat obscure.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no mention of sibling alternatives. The only usage hint is 'Task text discarded,' which tells the agent what not to pass, but there is no direction on which of the 9 optional parameters should be supplied or why one would invoke this tool instead of a sibling.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose that no browser is launched, but it does not state whether a network request is made, whether there are side effects, what permissions are needed, or what failure modes exist. 'Can be opened' remains vague about the actual 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 two short sentences with no filler. It front-loads the core action and immediately adds the key behavioral qualifier. Every word earns its place.

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

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

For a tool with 9 parameters, no annotations, and no output schema, this one-sentence description is inadequate. It does not explain which parameters are relevant, what 'opened' means, what the tool returns, or when to choose it over sibling tools. The description covers only the most basic purpose.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the tool description adds no parameter-level meaning. Several parameters like ref, city, json, and query seem unrelated to checking whether a URL can be opened, and the description does not clarify how they relate to the tool's purpose. The schema descriptions help, but the overall parameter story is confusing.

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

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

The description states a specific action ('Check whether a URL can be opened') and a resource ('a URL'), and adds a useful qualifier ('No browser is launched'). However, 'can be opened' is somewhat ambiguous—it could mean URL syntax validation, network reachability, or browser compatibility—and the description does not explicitly differentiate it from siblings like playwright-url-ok or fetch-status beyond the no-browser note.

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. It does not mention fetch-status, playwright-url-ok, normalize-url, or any other sibling, nor does it state when the tool is or is not appropriate. The no-browser note hints at a distinction but does not provide actionable usage direction.

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 disclose one trait — 'Expression discarded' — signaling that the evaluated input is not retained or propagated. But it says nothing about side effects, return values, error behavior, or what the caller receives, which is minimal coverage for an evaluation tool.

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

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

The description is two terse sentences with no wasted words, and the purpose is front-loaded in the first sentence. The brevity is earned, though it leans toward under-specification rather than efficient completeness.

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 output schema, and no annotations, a six-word description is not sufficient. It omits what the tool returns, which parameter is the expression to evaluate, whether the result is echoed or suppressed, and when this tool is preferable to its shape-checking siblings. An agent could not invoke it correctly with confidence.

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

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

Schema coverage is 100%, so the baseline is 3, but the description fails to add meaning and actively creates confusion: it describes evaluating an expression while the schema exposes only ref, url, city, feed, host, json, path, query, and zone — none of which can carry an 'a+b' expression. An agent cannot determine which parameter serves as the arithmetic input from either the description or the 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 names a specific verb and resource ('Evaluate a+b style arithmetic'), so the core purpose is stated. However, 'Expression discarded' muddies whether the tool returns the evaluated result or merely validates syntax, and the stated purpose maps to no field in the 9-parameter schema, which contains no arithmetic expression parameter. This leaves an agent unsure what the tool actually produces.

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 no guidance on when to call calc-eval versus its 28 siblings, many of which share the same schema shape (file-path-ok, validate-json, search-query-len). No context, conditions, or alternatives are mentioned, so the agent must infer usage entirely 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?

With no annotations provided, the description carries the full burden of disclosing behavior, and it discloses none. It does not mention read-only behavior, side effects, validation, return values, or how inputs are handled. The schema notes about discarded values are not part of the tool description.

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 free of filler, but it is under-specified rather than appropriately concise. It omits the core operational detail, so its brevity is not earned.

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 heterogeneous optional parameters, no output schema, and no annotations, a single noun phrase is severely incomplete. An agent cannot determine what to pass, what will happen, or what the tool returns.

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

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

Schema description coverage is 100%, so all 9 parameters already have individual descriptions. The tool description adds no parameter-level meaning, but the schema carries that load; this aligns with the baseline of 3 for 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 names a resource ('Public ISO 3166-1 record for EH') but does not state an action. There is no verb explaining whether the tool returns, validates, cites, or checks something, and it does not differentiate itself from the many sibling tools.

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

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

No guidance is given about when to use this tool versus any sibling. There are no conditions, exclusions, or alternative tool references. The 'for EH' scope is only a weak hint and does not clarify invocation context.

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

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

With no annotations provided, the description must carry behavioral context. It does add one meaningful behavioral trait: 'Page content is not stored,' which is useful privacy information. However, it does not disclose whether the page is fetched, what happens to the other parameters, or anything about errors or side effects, so the disclosure is incomplete.

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

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

The description is tightly written and front-loaded: the core purpose appears in the first sentence, and the privacy caveat earns its place in the second. It loses a point only because it may be too terse given the unusually broad and cryptic 9-property 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?

There is no output schema, annotations, or required-parameter signal, and the description covers only the URL aspect while the schema includes unrelated-looking parameters like city, feed, json, and path. An agent is left without enough context to know what to pass or what the tool will do with those parameters. The description is not complete enough for safe invocation across the schema.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description adds no parameter-level detail. The description only reinforces the 'url' concept by mentioning URL, host, scheme, and HTTP status, but it does not explain the many other schema properties or their relationship to the tool's stated purpose.

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

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

The description states a specific action ('Return') and a specific resource/output ('host, scheme, and HTTP status for a URL'). It clearly distinguishes this tool from siblings like normalize-url and web-fetch by naming the exact fields returned. The addendum that page content is not stored further clarifies what the tool does not do.

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

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

No guidance is given about when to prefer this tool over the many sibling URL-related tools. The description implies a URL-checking use case but does not state alternatives, exclusions, or conditions such as 'use fetch-status for status only' or 'use normalize-url for normalization.'

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

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

With no annotations, the description carries the full burden. It adds one useful behavioral note ('No identifiers are retained'), but it does not say whether the tool performs external calls, whether it is read-only, what side effects occur, or how input is actually processed. This is insufficient for an unannotated tool.

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

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

The description is short and front-loaded with the main action, followed by a relevant privacy note. There is no filler, though the brevity contributes to its 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?

A tool with nine optional parameters, no output schema, and many closely related sibling tools needs a more complete description. The agent is left to guess what classification result is returned, how to choose among parameters, and how this relates to the alternative tools.

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

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

The input schema provides 100% description coverage, with each parameter having a meaningful explanation (e.g., 'discarded after the shape check', 'HTTPS URL to normalize or cite'). The tool description itself adds no parameter semantics, so the baseline 3 applies.

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

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

The description states a verb and object ('Show how this request is classified') but never defines what classification means or what the result looks like. It does not distinguish this tool from specialized siblings like validate-json, domain-shape, or normalize-url, so an agent cannot tell what unique role 'compatibility' plays.

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 the many sibling shape-checking tools. It does not explain whether this is a router to other tools, a pre-check, or a standalone classifier, and it gives no conditions, exclusions, or example triggers.

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 full burden. It discloses the core split action and the non-goal of WHOIS/ownership, but it doesn't say which of the 9 parameters is actually used, whether the others are silently ignored, whether any network/disk access occurs, or what happens for malformed hostnames. The schema's per-parameter discard notes are partially helpful but not enough.

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; the key action is first, and the no-WHOIS clarification is the only necessary qualifier.

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

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

For a tool with 9 optional parameters, no annotations, and no output schema, the description is too thin. It doesn't specify input selection, return shape (e.g., list of labels), or edge-case behavior, so an agent can't fully predict invocation results.

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

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

Schema description coverage is 100%, so the baseline is 3; the description adds only a loose association between 'hostname' and the `host` parameter. It doesn't help an agent decide whether to pass `url`, `path`, `json`, or other fields, since those are absent from the description.

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

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

The description states a specific operation ('Split a hostname into labels') and a clear exclusion ('without WHOIS or ownership data'), which distinguishes it from ownership-lookup and URL-normalization siblings. However, it doesn't acknowledge the 9-field input schema, so the purpose is clear in isolation but slightly mismatched with the accepted parameters.

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

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

The description implies the tool should be used when an agent needs dot-separated hostname labels and should not expect ownership data. It names no alternatives or explicit when-not conditions, so routing among sibling shape and URL tools is left to inference.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose the HTTP method (HEAD) and that only status is returned, but it does not explain what happens with the many accepted parameters, whether redirects are followed, what error behavior looks like, or what 'status' means in the output.

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 states the action, the target, and the output scope efficiently.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, one sentence is not enough. The description does not specify which parameter is the URL to HEAD, what the status return looks like, or how the many discarded parameters should be handled, leaving material 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 parameter descriptions already carry the meaning. The tool description adds little beyond naming a 'public URL', which only loosely maps to the 'url' parameter and does not clarify the role of the other eight 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 a specific action ('HEAD a public URL') and the result ('return status only'), which is more than a tautology. However, it does not distinguish this tool from siblings like browser-url-ok, playwright-url-ok, or web-fetch, so an agent may not know which URL-checking tool to choose.

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 usage context: when you need only the HTTP status of a public URL, not the content. But it gives no explicit guidance about when not to use it or which sibling tool to prefer, leaving selection among many URL-related siblings to inference.

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

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

With no annotations, the description bears the burden of disclosing behavior. It does add a meaningful behavioral detail ('Path discarded'), but it leaves other important aspects unstated, such as whether the tool validates, normalizes, extracts, or only checks shape, and what it returns.

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

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

The description is two short sentences with no filler. The core purpose is front-loaded, and the 'Path discarded' caveat is separated cleanly.

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, no annotations, and many sibling shape/URL tools, the description is too sparse. It leaves the agent guessing which parameter to populate, what the tool returns, and how this tool differs from similar URL-related siblings.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds a useful constraint by clarifying that the URL in question should be a Figma file URL, but it does not map any of the nine schema parameters or indicate which one carries 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 states a specific operation ('Parse') on a specific resource ('Figma file URL'), so the tool's core purpose is clear. It does not explicitly contrast itself with sibling URL/shape tools, but the Figma-specific resource is enough to narrow the agent's selection.

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 is for Figma file URLs, but it provides no explicit guidance about when to prefer it over sibling tools like normalize-url, browser-url-ok, or the other *_shape tools. The intended use case must be inferred rather than stated.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does state a key behavior—'No disk access'—which signals no side effects on the filesystem. However, it does not describe the return value, what 'safe' means, or how invalid inputs are handled.

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

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

Two terse sentences with no filler; the core purpose and the key limitation are both front-loaded. 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 exposes nine optional parameters spanning domains unrelated to paths, such as city, feed, host, json, zone, query, and ref, but the description never explains whether these are alternatives, ignored, or part of a broader validation contract. With no output schema and no annotations, an agent lacks enough information to invoke the tool confidently beyond the path parameter.

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

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

Schema description coverage is 100%, so the baseline is 3, and the description adds little parameter-level meaning. The schema already documents each string parameter, including the path field, so the tool description does not need to repeat those details.

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

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

The description names a specific verb and resource: 'Check whether a path looks safe.' It also adds a valuable constraint with 'No disk access,' which clarifies this is a syntactic check rather than a filesystem probe. It does not explicitly distinguish itself from sibling tools, but the path focus is clear enough to separate it from URL/title/shape 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?

The description provides no explicit when-to-use or when-not-to-use guidance and names no alternative tool. 'No disk access' implies a safe syntactic-check context, but an agent must infer when this tool is the right choice versus a sibling like browser-url-ok or domain-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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions Open-Meteo, implying an external geocoding call, but does not disclose which input is used, whether the call requires network access, failure behavior, or the shape of the returned coordinates.

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 conveys the core purpose and external source in ten words, so 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?

Given 9 optional parameters, no required fields, no output schema, and no annotations, this one-sentence description is insufficient for reliable invocation. An agent cannot tell which parameter to pass, what the response structure will be, or how errors should be handled.

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 structured descriptions already document every parameter. The description adds only a loose connection between 'a place' and the city input, but it does not clarify which of the nine optional parameters geo-hint actually consumes or why the other parameters appear 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 identifies the tool's output—latitude and longitude for a place via Open-Meteo—and distinguishes it from weather-focused siblings like weather-hint. However, it lacks an explicit verb and does not name or contrast any sibling tool, so it falls 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?

Usage is implied: an agent can infer this tool is for geocoding a place to coordinates. But there is no explicit guidance about when to choose this over alternatives, which parameter to provide, or any exclusions or prerequisites.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only says 'Parse owner and repo' and does not disclose failure behavior, output format, side effects, or what happens with malformed or non-GitHub URLs. The schema descriptions mention that some values are 'discarded after the shape check,' but the tool description itself adds no behavioral context.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to the core purpose. It is appropriately concise for a simple parsing tool, though it sacrifices completeness 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 9 parameters, no annotations, and no output schema, this description is incomplete. It does not state which parameter should receive the GitHub URL, what the parsed owner/repo result looks like, how errors are handled, or whether the other parameters are ignored or rejected. An agent would need to infer too much from the generic schema.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds the important context that the URL is a GitHub URL and that owner/repo are extracted, but it does not clarify which of the 9 parameters is actually relevant, nor does it explain how the other parameters relate to this tool. The description adds some meaning beyond the schema but does not fully disambiguate the parameter set.

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: 'Parse owner and repo from a GitHub URL.' This clearly explains what the tool does and the domain of input. However, it does not explicitly differentiate it from sibling tools like normalize-url, domain-shape, or figma-url-shape, so it is clear but not fully distinguished.

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 normalize-url or figma-url-shape. The description implies the use case of a GitHub URL, but it does not state exclusions, prerequisites, or scenarios where another sibling tool would be preferred.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does disclose that titles are discarded, which tells the agent not to expect story titles in the result. However, it omits other behaviors such as whether a feed URL is required, how freshness is determined, 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 with no filler; the core action is front-loaded and the clarification earns its place. This is an appropriately minimal 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 tool has nine optional parameters and no output schema, yet the description does not explain which parameter(s) are relevant or what the response contains. An agent would not know whether to pass a feed URL or no arguments, nor how to interpret the result.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters. The description adds little parameter-level meaning beyond echoing 'titles discarded', which maps loosely to the feed parameter description.

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

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

The description names a specific verb and resource: count current Hacker News front-page stories. The addendum 'Titles discarded' clarifies that the result is a count rather than story content. This is distinct from sibling tools such as web-fetch or fetch-status.

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

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

There is no guidance on when to use this tool versus alternatives, nor any mention of required input or context. The description simply states what the tool does, leaving the agent to infer when it is appropriate.

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

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

There are no annotations, so the description carries the full burden of disclosing side effects, safety, or internal behavior. It discloses none of this; it does not even state whether the tool returns data, performs a check, or simply provides a static list. The schema's repeated 'discarded' language suggests side-effect-free behavior, but the 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 extremely short, which is superficially concise, but it is under-specified to the point of being unhelpful. It lacks an action verb, behavioral context, and usage guidance, so brevity is not serving the agent effectively.

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

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

This tool has nine parameters, no annotations, no output schema, and a description that fails to explain what the tool does or what the agent should expect from a call. Given the complexity of the input schema and the need to disambiguate from 25 siblings, the description is far from 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%, with each parameter individually documented, including notes on being discarded after checks. The description adds no parameter meaning, but the schema already does the heavy lifting, so the baseline 3 is appropriate.

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

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

The description is a noun phrase ('Common IANA timezone names for clock calls') with no verb indicating what the tool does—whether it lists, validates, resolves, or returns a timezone name. It names a resource domain but does not state an operation, and it does not distinguish itself from sibling tools like timezone, utc-time, or geo-hint.

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

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

The only contextual hint is 'for clock calls,' which implies a relationship to time-related tools but gives no explicit guidance on when to choose this tool over timezone, utc-time, or any sibling. No exclusions, prerequisites, or alternative routing are 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 provided, the description carries the transparency burden. It does disclose that the tool performs a network fetch of a public resource and limits its return to group counts, which conveys a read-only mental model. It does not mention failure modes, rate limits, or whether the URL parameter is the only meaningful input, but the core behavior is not hidden.

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

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

The description is a single front-loaded sentence with no filler. Every word contributes to the core function and output scope, making it highly concise 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?

This tool has 9 optional parameters, no output schema, and no annotations, so the description must do more work. It does not explain which parameter to use for the robots.txt URL, what group counts represent, or how the other parameters relate to the operation. The one-line description is inadequate for correct invocation in a complex parameter space.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description adds no parameter-level detail. The description does not indicate which of the 9 optional parameters supplies the robots.txt URL, but the schema already documents each parameter individually.

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

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

The description names a clear verb and resource: fetch a public robots.txt and return group counts only. This differentiates it from generic fetching tools like web-fetch or fetch-status by scoping it to robots.txt parsing. However, it does not explicitly contrast it with any sibling tools, so it misses the full differentiation step.

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 instead of alternative siblings such as web-fetch, fetch-status, or domain-shape. It only says public robots.txt, implying it should not be used on private resources, but does not state conditions, exclusions, or alternative selection criteria.

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

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

With no annotations, the description carries the full burden. It does disclose that the key is discarded, suggesting a non-persistent validation operation, but it omits any return behavior, error cases, or side-effect boundaries. The mismatch between the described 'key' and the schema's seven unrelated parameters further clouds what actually happens.

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

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

The text is brief and front-loaded, but it is under-specified rather than appropriately concise. The second sentence 'Key discarded.'' raises ambiguity since no key parameter exists, and the entire description omits necessary operating context.

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 seven parameters, no output schema, and no annotations, the description should identify the relevant input and expected behavior. It does neither; the core input is undefined and the fate of other parameters is unaddressed. An agent cannot reliably invoke this tool from the given definition.

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 refers to a Jira issue key, but the input schema contains no 'key' property—only ref,url,city,feed,host,json,path with unrelated descriptions. It adds no helpful parameter meaning and actively misleads an agent trying to determine which input to pass. Schema coverage for the intended key parameter is effectively zero.

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

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

The description states a specific verb and resource: 'Check a Jira issue key shape.' This distinguishes it from sibling shape-checking tools like github-repo-shape or domain-shape. However, it does not explain what 'shape' entails or which input to provide, and the mention of a discarded 'key' is ambiguous given the schema.

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

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

No guidance is given about when to use this tool versus the many sibling tools, nor are exclusions or alternatives mentioned. The description implies a validation use case but leaves the selection criteria entirely to inference.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal that the body is discarded, but it says nothing about network side effects, redirects, timeouts, rate limits, authentication, or the overall response shape beyond 'HTTP status'. This is under-disclosed for a tool that appears to make network requests.

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 two sentences are terse and front-loaded, and every word contributes. However, for a tool exposing nine optional parameters and no output schema, this brevity is under-specification rather than appropriate concision.

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

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

Given no output schema, no annotations, and a broad polymorphic-looking schema, the description is far too thin. It explains only a single URL-status behavior and silently leaves the other eight parameters and their behavior unexplained, so an agent cannot confidently call the tool outside the narrow library-docs-url case.

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 the schema describes each parameter, the tool description does not map 'public library docs URL' to the url parameter, whose schema description says 'normalize or cite' rather than 'check HTTP status'. The description also provides no relationship between the nine optional parameters and no indication of which field selects the documented behavior, so the description adds little usable semantic value.

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

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

The description states a specific output, HTTP status for a public library docs URL, and notes that the body is discarded, which gives a narrow but recognizable purpose. However, it never explicitly says 'returns' or 'gets', does not mention the nine optional parameters, and does not differentiate itself from sibling status/fetch tools 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?

There is no guidance on when to use this tool instead of fetch-status, web-fetch, normalize-url, or other siblings. No when-not conditions or alternative routing are provided, leaving the agent to infer usage solely from the name and one-sentence 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?

With no annotations, the description carries the full burden of behavioral disclosure. It reveals that values are discarded, which is useful, but it does not clarify whether nested keys are counted, what happens for invalid JSON, whether the operation is purely local, or what the result format is. This is too thin a behavioral picture for an agent to rely on safely.

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, front-loaded, and contains no filler; both sentences earn their place. It is economical to the point of omitting useful context, but those omissions are better penalized under contextual completeness rather than 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?

For a tool with nine optional parameters, no required parameters, no output schema, and no annotations, a two-sentence description is inadequate. It does not identify which parameter holds the JSON object, what the returned count looks like, or how invalid input is handled. An agent would likely need to inspect sibling tools or experiment 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 itself does not map 'JSON object' to the 'json' parameter, and the schema wording for json says 'validate' rather than 'count keys,' leaving a mild semantic mismatch. However, the schema already documents each parameter, so the description adds little but does not need to fully 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 states a specific verb and resource: 'Count keys in a JSON object.' It also adds a key distinguishing behavior by saying values are discarded, which separates it from validation or shape-checking tools like validate-json. It does not explicitly name a sibling or cover edge cases, 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?

No guidance is given about when to use this tool versus alternatives such as validate-json or domain-shape. The description does not state prerequisites, exclusions, or conditions that would make another sibling tool more appropriate. With 27 sibling tools, this absence is significant.

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 must carry the behavioral burden. It discloses the key transformation (query and fragment dropped) but omits whether the tool makes network calls, whether only the url parameter is actually consumed, and what happens with invalid URLs.

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

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

Two short, front-loaded sentences with no filler. The first sentence names the output, and the second states a key behavioral constraint.

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 or output schema, and a confusing nine-parameter schema with zero required fields, the description is too thin. It never states that url is the meaningful input, how the returned origin/host/path are structured, or how to handle invalid input.

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 meaning to the url parameter by specifying what normalization does, but it does not clarify how the many other schema properties relate to this tool or which ones should be passed.

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

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

The description clearly states a specific action and resource: "Return origin, host, and path for a URL." It also adds a defining transformation (query/fragment dropped), which distinguishes it from status-check or fetch tools in spirit, though it does not explicitly name or differentiate 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?

The description implies use when a caller needs normalized URL components, but it does not state when to use this tool versus status/fetch/shape-check siblings. No when-not guidance is given, and the nine-parameter schema is not addressed.

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

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

With no annotations provided, the description must fully disclose behavioral traits. It does not. It mentions 'Query text discarded' and that parameters are 'discarded after the call' in the schema, but the description itself is opaque about side effects, data access, or what the tool actually does. The description is misleading as it suggests returning documentation but fails to explain how the tool behaves.

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 statement, but it is under-specified rather than concise. It contains vague phrases like 'living people-search index' and 'remote MCP hops' that add no clarity. While every word is sparse, it does not earn its place because it fails to inform.

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

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

Given the tool's complexity (9 parameters, no output schema, no annotations), the description is severely incomplete. It provides no information about return values, side effects, or how the tool is expected to be used. An agent would not be able to call this tool correctly based on the description alone.

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 does not add any meaning to the parameters beyond the schema. Although schema coverage is high (100%), the description gives no insight into how these parameters are used collectively or what the tool does with them. It only repeats that some are 'discarded', which is unhelpful. The description fails to compensate for the tool's unclear purpose.

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

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

The description does not clearly state what the tool does. It mentions 'Find a living people-search index (Ploid)' but this is extremely vague and does not convey a specific verb-resource relationship. The additional phrases 'Returns CLI setup, docs, API, and remote MCP hops' are confusing and do not clarify the tool's purpose. It fails to distinguish from sibling tools like 'agent-tool-index' or 'lib-docs-hint'.

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

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

There is no guidance on when to use this tool versus alternatives. The description provides no context for selection, no exclusions, and no mention of alternative tools. An agent would have no idea why to invoke this tool over others.

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 one significant trait: no browser is launched, which is useful and safety-relevant. However, it does not say whether it makes a network request, what 'can be opened' means, or what the result looks like.

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

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

The description is two short sentences with every word earning its place. The main behavior is front-loaded and the important 'no browser' caveat follows immediately.

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

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

The tool has 9 parameters, no output schema, and no annotations, so the description must explain more than it does. It does not define what 'can be opened' means or what the tool returns, nor does it clarify how the non-URL optional parameters relate to the core check. An agent is left to guess the return contract and success criteria.

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 provides descriptions for all 9 parameters, so the baseline is 3. The description adds no new parameter meaning beyond reinforcing that `url` is the central input, but it does not compensate for the ambiguity around the many optional discarded fields.

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

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

The description says 'Check whether a URL can be opened', giving a clear verb, resource, and expected outcome. 'No browser is launched' adds a useful qualifier. It does not explicitly name or contrast sibling tools such as browser-url-ok or fetch-status, so it misses the full differentiation needed for 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 about when to use this tool versus alternatives like browser-url-ok, fetch-status, or normalize-url. The description does not provide context for selecting it or mention what to do in other situations.

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 disclosure burden. It states the query is discarded, hinting at non-persistence, but it does not say what is returned, whether the other accepted parameters are ignored or processed, or whether any validation or fetching 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 action is front-loaded and the discard note is helpful. The brevity is efficient, though it leaves semantic and contextual gaps scored elsewhere.

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

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

This is a high-complexity definition: nine optional parameters, no annotations, no output schema, and many siblings. The description does not explain how to select a parameter, what the successful response looks like, or what happens when multiple parameters are supplied, so an agent cannot confidently invoke it from the definition alone.

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 is already documented, including query as 'Search text; discarded after the length check.' The description adds no parameter-level detail beyond aligning 'search query' with the query field, so the baseline of 3 applies.

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

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

The description names a concrete operation ('Count characters') and a resource ('a search query'), and 'Query discarded' adds scope. It is clear on its own, though it does not explicitly distinguish itself from sibling count/length tools such as memory-key-count or hn-front-count.

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 prefer this tool over alternatives, no exclusions, and no mention of prerequisites. The implied use case, needing a character count of a search query, is too thin given the large sibling set and nine optional input parameters.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses almost nothing beyond the word 'catalog', which only weakly implies a read-only reference. It never states that inputs are checked and discarded, that no disk access occurs, or what the output looks like. Those behaviors surface only in the schema's parameter notes, not in the description.

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

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

The single sentence is terse and front-loaded, but it is under-specified rather than concise for a tool with eight heterogeneous parameters. Every word earns its place only in the sense that there are few words; the omission of behavior, output, and usage makes the brevity a liability.

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 eight heterogeneous parameters, no annotations, and no output schema, a one-sentence description that fails to state the return value, input-selection rules, or sibling relationships is far from complete. The schema's per-parameter notes (e.g., 'discarded after the shape check', 'no disk access', 'titles discarded') provide fragmented context but do not assemble into a coherent behavioral picture.

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

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

Although the schema documents all eight parameters (high coverage, so the baseline is 3), the description adds no parameter meaning and actively conflicts with the parameter set: a catalog of HTTP status codes has no evident use for a city name, RSS feed, JSON text, or file path. The description leaves the agent unable to tell whether it should pass one parameter, several, or none.

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 nearly a tautology of the tool name ('status' + 'catalog'), adding only the domain 'common HTTP status codes' without any verb stating what the tool does. It never reconciles the stated purpose with its eight heterogeneous inputs (git ref, URL, city, feed, host, JSON, path), which imply checking/validation behavior rather than a static catalog. It also fails to differentiate the tool from siblings like fetch-status, web-fetch, 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?

There is zero guidance on when to use this tool versus any of its 13 siblings, several of which overlap heavily (fetch-status, web-fetch, validate-json, normalize-url). The description names no alternatives, no prerequisites, and no exclusions. An agent cannot determine whether to invoke this tool for a URL check, a JSON validation, or a static lookup.

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

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

With no annotations, the description carries the full disclosure burden. It explicitly reveals the most important behavioral trait: the prompt is discarded, so the tool does not perform real reasoning or use the caller's instructions. It does not describe the exact template contents, but the critical behavior is clear.

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 deliverable is stated first and the key caveat second. Every word earns its place and the description is easy 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?

The description plus schema is enough to make a safe no-argument call and understand that the prompt is ignored. However, it does not spell out what the three-step template actually contains or when to prefer this tool over the many sibling tools, and there is no output schema to fill that gap.

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

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

Schema description coverage is 100%, so the schema already documents every parameter well. The description adds global context by saying the prompt is discarded, but it does not add per-parameter meaning beyond what the schema provides, so a baseline 3 is appropriate.

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

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

The description states a specific verb ('Return') and a specific resource ('a three-step thinking template'), then adds the key caveat that the prompt is discarded. This makes the tool's role immediately distinct from the many checking and fetching siblings, even though no sibling is named.

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

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

There is no guidance on when to use this tool versus alternatives. 'Prompt discarded' hints that this is not a real reasoning tool, but it never explicitly says to use it only for generic template requests or that actual analysis should be handled by another tool.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It conveys a non-mutating time lookup, but it does not explicitly state that non-zone inputs are ignored or describe the returned time format.

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

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

One compact sentence with no filler. The essential operation is front-loaded, and no sentence could be removed without losing meaning.

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

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

For a low-complexity lookup, the description plus schema is mostly sufficient. However, the tool has no required parameters, so the description does not clarify that zone is the operative input, and there is no output schema to indicate the response 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?

Schema description coverage is 100%, so all parameters including zone are documented in the schema. The description adds little beyond naming IANA timezones, so the baseline score of 3 applies.

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

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

The description clearly identifies the tool's job: return the current time for a named IANA timezone. It implicitly distinguishes itself from siblings like utc-time and iana-zones, though it lacks an explicit verb such as 'returns'.

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

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

The description implies the use case: use this when you need current time in a named IANA timezone. However, it does not explicitly mention alternatives or state when not to use it, leaving the decision boundary to inference.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only states that the timestamp is current; it does not mention that the tool has no side effects, that the many input properties are ignored or discarded, or how the timestamp is formatted. The unusual input schema makes this omission noticeable.

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

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

The description is extremely short and front-loaded with the essential output. There is no wasted text, though it reads as a noun phrase rather than an instruction.

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

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

For a tool with no output schema and seven unrelated-looking optional parameters, this description is undersized. It does not clarify why those parameters exist or whether they affect the returned timestamp, and it leaves the return format unspecified.

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

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

The schema descriptions already cover every parameter in detail, including that values like 'ref' and 'city' are discarded after checks. The tool description adds nothing about parameters, but because schema coverage is high, 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 phrase 'Current UTC timestamp' clearly communicates that the tool returns the absolute current UTC time value. It is understandable, but it does not actively distinguish itself from near-sibling tools such as timezone or iana-zones.

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

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

There is no guidance on when to use this tool versus alternatives like timezone or iana-zones. The intended use case is only implied by the name and description, not explicitly stated.

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

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

There are no annotations, so the description carries the full behavioral burden. It discloses that the body is discarded, but it does not explain what happens for valid versus invalid JSON, whether any external calls are made, 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?

The description is two short sentences with no waste. The core action is front-loaded and the side-effect statement is relevant and concise.

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

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

With no output schema, no annotations, and seven parameters, the description is too sparse. It does not state the return value, error behavior, or how the 'body' maps to the `json` parameter, leaving important gaps for an agent deciding how to invoke it.

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

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

All parameters have schema descriptions, so schema coverage is high. The description adds little beyond the schema; the `json` parameter is already described as 'JSON text to validate; discarded after the check'. The description does not clarify why the schema includes the unrelated-looking 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 states a specific verb and resource: check whether a body is valid JSON. It is distinct from the sibling shape/URL validation tools. However, 'body' is not a named input parameter (the schema lists `json` instead), which introduces minor ambiguity.

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

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

No guidance is given about when to use this tool versus alternatives, and no exclusions or prerequisites are mentioned. The agent must infer from the name and siblings that this is the JSON-validation choice.

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 must carry the full behavioral burden. It says the data comes from Open-Meteo and implies a read-only lookup, but it does not disclose the return format, units, failure behavior, or the fact that many schema fields appear to be unrelated/discarded. This is a significant transparency 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 that front-loads the core operation and data source. There is no redundant wording or filler.

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

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

Given the lack of an output schema and annotations, plus a nine-parameter input schema containing many seemingly unrelated optional fields, the description is not complete enough. An agent can guess that city is relevant, but it cannot reliably determine the expected output shape or whether other schema properties are truly ignored.

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

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

Schema coverage is 100%, so the baseline is 3. The schema descriptions themselves hint that city is the weather-related input and that other fields are discarded, but the description adds no parameter-level guidance and all parameters are optional, leaving doubt about which field is actually needed.

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, concrete operation: returning current temperature for a city via Open-Meteo. It is not a tautology and is clear enough for an agent to understand the tool's basic purpose, though it does not explicitly differentiate from sibling tools like geo-hint.

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 makes the intended scenario clear: use this tool when current temperature for a city is needed. It provides no exclusions or named alternatives, but the use case is directly stated rather than merely 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?

There are no annotations, so the description bears the full transparency burden; it clearly discloses that the response body is not returned and only status/content type remain. It does not cover edge cases such as redirects or errors, but the main behavioral constraint that prevents misuse is explicitly stated.

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, no filler, and the returned information plus the body-discard constraint are front-loaded. Every word earns its place.

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

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

For a 9-parameter tool with no annotations and no output schema, this description does not explain how optional inputs such as city, json, zone, query, path, or feed relate to fetching a public URL. The schema documents each parameter individually, but the overall contract remains ambiguous because it is unclear which parameter is the primary fetch target.

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 nine parameters are already documented and the baseline is 3. The tool description adds no additional parameter-level meaning beyond referring to a public URL, so it neither improves nor harms parameter understanding.

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 output (HTTP status and content type), the scope (public URL), and a key constraint (body discarded), so the tool's purpose is clear. It does not contain an explicit verb like 'fetch' and does not differentiate it from sibling tools such as fetch-status or browser-url-ok, 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?

'Body discarded' plus 'public URL' implies that this tool is appropriate only when headers/status are sufficient and the target is publicly reachable. The description never names an alternative or explicitly says when not to use web-fetch, so the guidance 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 exist, so the description carries the behavior disclosure burden. The sentence 'Title discarded after the call' is a genuine retention/privacy disclosure beyond the schema. However, it does not state read-only behavior, network usage, errors, or side effects, leaving a meaningful transparency 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 short and front-loaded with the core purpose, with no wasted text. The second sentence adds a useful data-retention note instead of repeating the first. Its brevity is a strength, though it sacrifices necessary 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?

With no output schema, no annotations, and seven optional-looking parameters, the description must explain what to pass and what to expect, but it does neither. The title parameter is missing entirely, and the return type is unspecified. The definition is inadequate for correct invocation.

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

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

The schema exposes seven unrelated string parameters—ref, url, city, feed, host, json, path—and none of them is a 'title' parameter. The description says a title is discarded but never identifies which field carries the title. An agent cannot determine how to invoke the tool correctly from this definition.

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

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

The description states a specific operation ('Check whether') on a specific resource ('a Wikipedia title exists'), so an agent can distinguish it from URL, path, and JSON checkers in the sibling list. It earns a 4 rather than 5 because it does not explicitly contrast itself with related existence checkers or describe the result format.

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 use case (verifying whether a Wikipedia title exists) but provides no when/when-not guidance or alternatives. There is no indication of how this tool differs from normalize-url, web-fetch, or other checking tools. This is only implied direction, not explicit routing.

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