ISO country WF

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

With no annotations, the description itself carries the behavioral burden and does disclose meaningful traits: a 302 redirect to start_here.hop, returning docs/CLI/remote MCP hops, and discarding task text. It omits a clear side-effect profile, but the disclosures go well beyond what the name or schema alone would convey.

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, front-loaded with the main purpose, and contains no filler. The important caveat 'Task text discarded' is placed last rather than earlier, but the overall structure is efficient.

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

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

The description gives high-level output categories but, with 9 optional parameters and no output schema or annotations, an agent is left guessing which parameter to populate or what the returned hops/docs look like. It is more complete than a stub, but not fully sufficient for correct invocation.

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

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

Schema description coverage is 100%, so the parameters are already documented and the description does not need to compensate. The description adds only the global caveat that task text is discarded, which is useful but not parameter-specific; 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 opens with a specific verb ('Find') and a specific resource ('public pay-per-call tool gateway (Monid)'), and the mention of returned artifacts distinguishes it from sibling check-utilities. It is not a 5 because 'Monid' and 'pay-per-call tool gateway' remain unexplained jargon, but an agent can infer this is a discovery/index tool.

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 sibling tools; no sibling names are referenced and no exclusions are stated. 'Follow start_here.hop first' is an internal step, not a selection criterion.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, yet it only reveals that no browser is launched. It does not disclose whether a network request is made, what 'ok' means, what side effects occur, or what the return value looks like. Some behavioral hints exist in the schema parameter descriptions (e.g., 'no disk access'), but these are not in the main 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 front-loaded with the core check, with no wasted words. However, for a tool exposing nine heterogeneous parameters and no output schema, this brevity is more under-specification than efficient conciseness; the structure does not help an agent map parameters to behavior.

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

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

This is a nine-parameter tool with no required parameters, no annotations, and no output schema, yet the description provides almost no context about how the parameters relate to the check, which parameter to choose, or what result to expect. The description is completely 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?

Schema description coverage is 100%, so each of the nine optional parameters already has an explanatory description. The main description adds no parameter-level meaning, and the baseline of 3 is appropriate given that the schema carries the documentation burden.

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

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

The description states a specific verb and resource: checking whether a URL can be opened. It also adds a distinguishing behavioral note, 'No browser is launched,' which separates it from browser-launching siblings like playwright-url-ok. However, 'can be opened' is ambiguous—it could mean syntactic validity, DNS resolution, or reachability—and the outcome is not described.

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

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

There is no explicit when-to-use guidance or mention of alternatives. The only contextual hint is the exclusion 'No browser is launched,' but no selection conditions or sibling comparisons are provided, leaving an agent to infer when this tool 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?

The description says 'Expression discarded' which hints at a side-effect-free behavior, but there are no annotations to confirm safety. The schema descriptions mention 'discarded after the shape check', 'no disk access', and 'discarded after the length check', which suggest read-only behavior, but the description itself does not disclose this. The mismatch between the arithmetic description and the schema's actual parameters is a transparency issue.

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 (one sentence), which is concise, but it is under-specified and misleading. The phrase 'Expression discarded' is vague and does not clarify what expression is being discarded. The description does not front-load the actual behavior of the tool, which appears to be a multi-purpose validator based on the schema.

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

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

With 9 parameters, no annotations, no output schema, and 29 siblings, the description is severely incomplete. The agent cannot determine what this tool does, when to use it, what it returns, or how the parameters relate to the stated arithmetic purpose. The description fails to provide even the basic context needed for correct invocation.

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

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

Schema description coverage is 100%, so the schema documents each parameter's meaning. However, the description says 'Evaluate a+b style arithmetic' but none of the 9 parameters represent an arithmetic expression. The description adds no value in explaining how the parameters relate to the stated purpose, and the agent cannot infer which parameter to use for the arithmetic evaluation.

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 'Evaluate a+b style arithmetic' which is a specific verb and resource, but the input schema has 9 unrelated parameters (ref, url, city, feed, host, json, path, zone, query) with no arithmetic expression parameter. This makes the purpose confusing and misleading. The description does not distinguish this from the 29 sibling tools, and the schema contradicts the stated purpose.

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

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

No guidance is given on when to use this tool versus any of the 29 siblings. The description does not mention any context, prerequisites, or exclusions. The schema's 9 parameters suggest it might be a multi-purpose checker, but the description only mentions arithmetic, leaving the agent with no idea when to invoke it.

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

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

No annotations are provided, so the description carries full burden. It gives zero behavioral traits: no mention of no disk access, no side effects, no validation semantics, no what gets discarded. The input schema hints at 'discarded after the shape check' but the description is silent, giving the agent no safety or side-effect awareness.

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 (6 words), which could be concise, but it's under-specified to the point of being useless. It is front-loaded with the only phrase it has, but that phrase carries almost no meaning, so the brevity harms rather than helps.

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

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

With 9 parameters, 29 siblings, no annotations, and no output schema, the description is grossly inadequate. The schema's hints about 'discarded' and 'no disk access' are the only behavioral context, and the description fails to synthesize any of that or provide usage guidance. A tool with 9 parameters needs far more explanation.

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

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

The input schema has 100% coverage, documenting all 9 parameters with individual descriptions. The description itself adds no parameter meaning beyond what the schema provides. Baseline 3 is appropriate because schema handles the burden; no compensation 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 'Public ISO 3166-1 record for WF.' is nearly a tautology, telling us it's a record for WF but not what the tool actually does. The purpose is vague, as it could be many things (lookup, validation, weather, etc.) and does not differentiate from the 29 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?

No guidance on when to use this tool versus any of the 29 siblings. The description does not state conditions for use, alternatives, or exclusions. An agent cannot decide when to invoke it based on this.

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

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

Annotations are not provided, so the description carries the burden of disclosing behavior. It does mention that 'Page content is not stored,' which is a form of behavioral transparency about data retention. However, the description is incomplete: it does not disclose that many parameters are 'discarded' (e.g., 'ref' is discarded), which is a behavioral trait. It does not state whether the tool has side effects, caching, or rate limits. Given the lack of annotations, the description should be more explicit about these behaviors.

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 purpose, but it lacks structure. It does not enumerate the parameters or explain the multiple modes of operation. The sentence 'Page content is not stored.' is appended without context. While it is concise, it is under-specified for a tool with 9 parameters.

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

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

This is a complex tool with 9 parameters and no output schema. The description is far from complete: it does not explain how the parameters interact, which are mutually exclusive, or what the exact output format is. It does not provide examples or enough information to use the tool correctly. The description does not cover the breadth of functionality implied by the parameter list.

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 has a description. However, the description adds confusion by listing parameters that seem unrelated to the primary purpose (e.g., 'city', 'query', 'json'). The description does not explain how these parameters relate to the main task of returning host, scheme, and HTTP status. It fails to clarify that many parameters are extras or validation checks, and does not help an agent decide which parameters to use together.

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

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

The description states that it returns host, scheme, and HTTP status for a URL, which is a specific verb and resource. However, the tool takes many parameters that do not all relate to a URL (e.g., city, feed, json, path, zone, query), making it unclear what the actual purpose is. It might be a generic dispatcher, but the description does not clarify that, and it does not distinguish it from siblings like 'normalize-url' or 'fetch-status'.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any conditions for using it over siblings like 'browser-url-ok' or 'fetch-status'. It only says what it returns, not when it should be used. The lack of required parameters and the broad set of inputs suggest it might be a general utility, but the description does not explain that.

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 add a useful privacy note ('No identifiers are retained'), but it leaves the core behavior obscure: what 'classified' means, what output is produced, and whether any external access or side effects occur. The schema already notes that most values are discarded, so the description adds only a global retention guarantee.

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

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

The description is two short sentences with no filler, and the primary action is front-loaded. It sacrifices helpful precision for brevity, but as far as sheer conciseness and structure go, it is effective.

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 a high-complexity signature (9 optional parameters, no required parameters, no output schema, no annotations), the description is far too thin. It does not explain how a request is classified, what the agent should expect in return, which parameters are appropriate in which situations, or how this tool relates to its siblings.

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

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

Schema description coverage is 100%, and each parameter has its own meaningful description (e.g., 'discarded after the shape check', 'no disk access'). The description itself adds no parameter-level semantics, so the schema carries the load. No aggregation guidance is provided about whether parameters are mutually exclusive or how they map to the classification.

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'), so it is not a tautology, but 'classified' is vague and never tied to the tool name 'compatibility' or to any classification scheme. It does not distinguish the tool from the many sibling tools that also accept URLs, file paths, queries, or JSON.

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

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

No guidance is given about when to call this tool versus alternatives like validate-json, domain-shape, or status-catalog. There are no exclusions, no prerequisites, and no hint about which of the nine optional parameters should be supplied.

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

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

Annotations are not provided, so the description carries full responsibility for behavioral disclosure. The description mentions that the tool splits a hostname, hinting at a read-only operation,, but it does not state whether any parameters are discarded (even though the schema's descriptions indicate several are), nor does it clarify that only the 'host' parameter is relevant. The lack of clear behavioral expectations is a significant gap.

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

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

The description is very short and to the point, with no unnecessary verbosity. The single sentence effectively states the core purpose and a key exclusion. It is well-structured for a description, though it could benefit from a bit more context about parameter usage.

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 9 parameters, lack of annotations, and no output schema, the description is grossly incomplete. It does not clarify which parameters are relevant, what the output is, or how to use it correctly. Even though the schema descriptions are rich (100% coverage), the description's lack of focus on the actual 'host' parameter and the tool's behavior leaves the agent under-informed. Significantly more guidance is needed for this multi-parameter tool.

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

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

Schema description coverage is 100% (all parameters have descriptions), so the baseline is 3, but the description adds nothing about parameters. The description only mentions 'a hostname', whereas the schema lists 9 unrelated parameters. The schema descriptions do provide some meaning, but the description does not help the agent understand which parameters are actually used for the shape check, especially since most are marked as 'discarded'.

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

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

The description states a clear verb ('split') and a specific resource ('hostname'), and explicitly notes that it excludes WHOIS/ownership data,, which differentiates it from its name. However, the schema lists many unrelated parameters (e.g., 'city', 'feed', 'json'), making the tool's actual scope ambiguous. The description is coherent with the name, but the schema-wide parameter list undermines clarity.

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

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

The description gives a hint about what the tool does not do (no WHOIS/ownership), which is some context, but it does not specify when to use this tool versus the numerous siblings (e.g., 'browser-url-ok', 'figma-url-shape', 'file-path-ok'). It lacks explicit conditions that would help an agent select it over similar-looking tools. The alternative to use is not named.

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

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

No annotations are provided, so the description carries the full burden. The description mentions 'HEAD' (implying no body download) and 'status only', which is a hint, but it doesn't disclose that most parameters are ignored/discarded, which is a significant behavioral trait. Also, the description doesn't address error handling, redirections, or rate limits.

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

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

The description is a single short sentence, which is concise and front-loaded with the main action. It earns its place, but given the complexity of the parameter set and the tool's odd behavior, it is under-specified, so a 4 is appropriate.

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

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

With 9 optional parameters, no output schema, and no annotations, the description is severely incomplete. It doesn't explain why so many parameters are accepted or how they relate to the operation relative to siblings. An agent would be uncertain about how to construct a valid call and what the response would look like.

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

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

Schema coverage is 100% because each parameter has a description, but those descriptions are largely misleading for this tool: they suggest the parameters actually do something (e.g., 'validate JSON', 'normalize URL'), while the tool description says it only returns status. Many parameters are described as 'discarded', but the purpose of accepting them is unclear. The description does not add value beyond the schema, and in fact contradicts the schema's implied semantics.

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

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

The description states a clear action ('HEAD a public URL') and the expected output ('return status only'), but the tool name is 'fetch-status' and the description doesn't clarify how this differs from siblings like 'browser-url-ok' or 'web-fetch'. The description is somewhat generic and could apply to multiple 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?

The description says 'public URL' implying it should be used only for public URLs, but it doesn't explicitly state when to use this tool instead of alternatives like 'browser-url-ok' or 'web-fetch'. No exclusions are given, and the presence of many unrelated parameters (city, feed, json) without guidance is confusing.

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

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

No annotations are provided, so the description carries the full burden. It says 'Path discarded' but does not explain what happens to the other parameters (e.g., city, feed, json, zone, query) which are described in the schema as 'discarded after the check' or 'discarded after the call'. The description does not disclose whether the tool performs network access, validation, or just shape checking. It also doesn't mention that it accepts many unrelated input types, which is a significant behavioral trait.

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 (one sentence), which is concise, but it is under-specified. It front-loads the main action but omits critical context about the tool's multi-parameter nature. The brevity is not effective because it leaves the agent with a misleading impression of the tool's purpose.

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

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

Given the tool has 9 parameters, no annotations, no output schema, and a description that only mentions Figma URLs, the description is incomplete. An agent cannot determine what the tool does with the other 8 parameters, whether it performs network calls, or what the return value looks like. The sibling list includes many similar shape-checking tools (domain-shape, github-repo-shape, jira-key-shape, proto-ok, wiki-title-ok), and this description does not differentiate figma-url-shape from them.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds no parameter-level meaning beyond the name 'figma-url-shape' and the phrase 'Path discarded.' It does not explain how the 'url' parameter relates to Figma or how the other parameters are used. Baseline 3 is appropriate because the schema covers all parameters, but the description fails to clarify the tool's actual scope.

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 'Parse a Figma file URL. Path discarded.' This states a verb and resource, but the input schema contains 9 unrelated parameters (city, feed, host, json, path, zone, query) with no mention of them in the description. The tool name suggests a Figma URL shape checker, but the schema suggests a generic multi-purpose validator. The description is too narrow and fails to clarify what the tool actually does with all these 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?

No guidance is given about when to use this tool versus siblings like browser-url-ok, normalize-url, or domain-shape. The description does not mention alternatives or exclusions. The presence of many unrelated parameters suggests the tool may be a generic shape-checker, but the description only mentions Figma URLs, leaving the agent confused about when to use it for other inputs.

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

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

No annotations are provided, so the description carries the full burden. It does disclose one important behavior: 'No disk access', which is a clear behavioral constraint. However, it does not explain what the tool actually does with the 'path' (e.g., what checks it performs), what the return format is (e.g., boolean, error message), or whether the 'path' parameter is optional given that many other parameters exist. It also does not disclose any side effects or side-effect-free nature beyond disk access; the phrase 'looks safe' is ambiguous. This is minimal disclosure for a validation tool.

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

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

The description is very short and to the point: 'Check whether a path looks safe. No disk access.' It is efficient, front-loads the purpose, and adds a key behavioral caveat. No wasted words. However, it could be slightly more structured by providing a tiny bit more detail on what 'safe' means, but that is a matter of content, not conciseness. For the length, it earns a high score.

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

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

The tool is relatively simple (a path check) with no output schema and no annotations. The description tells us it does not access disk, but it does not explain the expected output, error behavior, or how to interpret the result. With 9 parameters (though likely only one relevant), an agent might not know which parameter to use; the description only mentions 'path'. There is no guidance on handling invalid paths or what happens if other parameters are provided. The description is insufficient for an agent to confidently call the tool correctly.

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

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

The input schema has 9 parameters, all with descriptions that are present (100% coverage), but the descriptions are sparse and mostly just restate the parameter name (e.g., 'City name for a public weather hint' adds a bit of context but not much). The tool description does not explain how the 'path' parameter interacts with the others; it appears the tool might accept multiple types of inputs, but the description only mentions 'path'. Given high schema coverage, the baseline is 3, and the description adds minimal extra meaning (only 'no disk access' for path). It does not clarify that the other parameters are probably unused or irrelevant for this tool, which could confuse an agent.

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

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

The description 'Check whether a path looks safe. No disk access.' conveys a specific verb ('Check') and a resource ('a path'), and distinguishes the tool as a pure shape/validation check with no disk side effects. However, the description is terse and does not clarify what constitutes 'safe' (e.g., no traversal, no absolute paths), leaving room for interpretation. It partially differentiates from siblings by the 'no disk access' phrase, but it does not name any specific sibling alternative.

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

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

The description says 'No disk access', which implies the tool is for static analysis and should be used when you want to validate a path without touching the filesystem, but it does not explicitly state when to use it versus other validation tools (e.g., browser-url-ok for URLs, validate-json for JSON). There are no examples, no conditions, and no mention of when not to use it. The sibling list includes many similar validation tools, but the description provides no routing guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only says 'via Open-Meteo' and gives no disclosure about side effects, parameter discard behavior, network use, or error conditions, which is a significant gap given the schema already describes each param's ephemeral nature.

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

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

The description is a single short sentence with no irrelevant information, front-loading the key output. But its brevity is over-strict for a 9-parameter tool, which prevents it from earning a 5.

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

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

Given the high complexity (9 parameters, no annotations, no output schema), a one-line purpose statement is grossly insufficient. Nothing explains which parameter is the locus of 'a place', what the expected output format is, or how this tool relates to the geolocation family.

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 does not contradict the schema. However, it adds no meaning beyond the schema and fails to link any of the 9 unrelated-looking parameters (ref, url, city, feed, host, json, path, zone, query) to the geocoding function.

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

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

The description states a clear resource and output: latitude and longitude for a place, via Open-Meteo. It identifies the tool's specific function, but it lacks a direct verb and does not distinguish it from sibling tools such as weather-hint or timezone.

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

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

The description offers no when-to-use guidance, no mention of alternatives, and no exclusions. It only implies the tool produces coordinates, leaving the agent to infer when to choose this over siblings like weather-hint or iana-zones.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It only states 'Parse owner and repo' but does not disclose what the return object looks like, whether invalid URLs cause errors, whether any side effects exist, or that the operation is read-only. For a tool with zero annotations, this is a substantial 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, terse sentence with no filler. The core purpose is front-loaded and the sentence earns its place. There is no unnecessary repetition of the tool name or schema fields.

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 parameters, no output schema, and no annotations, the description is too sparse. It does not specify which parameter must be populated, what the returned owner/repo representation is, or how the other automatically discarded parameters affect behavior. The schema's own description for `url` ('HTTPS URL to normalize or cite') does not even align clearly with GitHub parsing, so an agent is left with ambiguity about how to invoke the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds GitHub-specific meaning to the generic 'HTTPS URL' parameter by implying it should be a GitHub repo URL and that owner/repo are extracted. It does not explicitly name the `url` parameter, and the other parameters are described as discarded in the schema, so the description adds some but not full 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 verb and resource: 'Parse owner and repo from a GitHub URL.' It clearly indicates the input domain (GitHub URL) and the output concept (owner and repo), which distinguishes it from sibling tools like figma-url-shape and jira-key-shape. This is enough for an agent to know what this tool does.

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

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

The purpose sentence implies the usage: call this when you need owner and repo extracted from a GitHub URL. However, there is no explicit guidance on when not to use it, no mention of alternatives, and no selection criteria relative to the sibling tools. It is a minimal implied usage rather than a thorough guideline.

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 says 'Titles discarded' and 'Count current' but doesn't disclose what the return value looks like, whether it makes a network request, or any side effects. The phrase 'Titles discarded' hints at a behavioral trait, but it's minimal and doesn't explain the output format or failure modes.

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

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

The description is very short and front-loaded with the core purpose. 'Titles discarded' is a useful clarification. It's efficient, though it could arguably include a bit more context without becoming verbose.

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 has 9 parameters, no output schema, and no annotations, the description is too sparse. It doesn't explain what the tool returns, how the parameters relate to the counting, or why so many parameters exist. An agent would struggle to know what to pass and what to expect back.

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

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

Schema description coverage is 100%, so the schema already documents all 9 parameters. The description adds no parameter-specific meaning beyond the schema. Baseline 3 is appropriate since the schema does the heavy lifting, and the description doesn't need to compensate.

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

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

The description states a specific verb and resource: 'Count current Hacker News front-page stories.' This clearly identifies the tool's purpose. However, it doesn't explicitly distinguish it from siblings like fetch-status or web-fetch, though the HN-specific scope is fairly unique.

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

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

No guidance is given on when to use this tool versus alternatives. The description doesn't mention any context, prerequisites, or exclusions. An agent would have to infer that this is for HN front-page counting, but there's no explicit routing or comparison to sibling tools.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it has no verb and never states what the tool does, returns, or whether it has side effects. The word 'Common' hints that the set is non-exhaustive, but that alone is insufficient for an agent to anticipate 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 definition is short and free of filler, so it is concise in length. That said, it is an under-specified fragment rather than a structured statement, and it leaves out the essential verb and behavior needed for a useful tool 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?

With 9 optional parameters, no output schema, no annotations, and a parameter set that looks unrelated to the stated purpose, a single phrase is far from adequate. An agent is left without information about what to pass, what the tool returns, or how it behaves.

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

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

Schema description coverage is 100%, so the baseline is 3; each parameter has its own description. However, the tool description adds nothing about how the 9 optional parameters relate to 'IANA timezone names', and several parameters such as url, city, feed, and json appear unrelated without additional explanation.

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

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

The description is a noun phrase that restates the tool name ('IANA timezone names') with only a vague context ('Common', 'for clock calls'). It never states whether the tool returns a list, validates a zone, or performs some other action, so an agent cannot know what invoking it yields. It also does not meaningfully differentiate it from siblings like timezone or utc-time.

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

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

The phrase 'for clock calls' provides a weak usage context, implying the tool is relevant when working with clock or timezone related tasks. However, there is no explicit guidance on when to prefer this tool over alternatives, no exclusions, and no mention of sibling tools such as timezone or utc-time.

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

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

No annotations are provided, so the description must fully disclose side effects and behavior. It does note that the tool 'discards' some parameters (ref, city, feed, json, query) and 'no disk access' for path, but it doesn't mention that the robots.txt content is not returned, only counts. It also doesn't state any caching, rate limits, or network behavior, leaving the agent uncertain about side effects.

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

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

The description is a single sentence, concise and to the point. It front-loads the action and output, and does not waste words. It could be more structured (e.g., bullet list of effects) but it earns its place.

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

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

With 9 parameters and only 0 required, the description is very incomplete. It does not explain which parameter is the primary target (URL? host?), whether any parameter is ignored for the core function, and what the output format looks like. Given the high complexity (many parameters, many are discarded), the description should clarify the effective input for the robots.txt fetch. This is a significant gap.

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

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

Schema coverage is 100%, so the schema describes each parameter's role. The description adds no parameter-level detail beyond that; 'url' and 'host' are both listed but not disambiguated (which is used to fetch robots.txt?). The description mentions 'group counts only' which implies a focus on the response, but not tied to specific parameters. Baseline 3 is appropriate since the schema carries the detail.

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 ('Fetch a public robots.txt') and a specific output ('return group counts only'). However, it does not clarify which parameter supplies the URL (likely 'url' or 'host'), and the name 'inspect-robots' is somewhat generic. It is distinguishable from siblings like 'fetch-status' but not from a generic web fetch tool without more context.

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

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

No guidance is given on when to use this tool over siblings like 'web-fetch' or 'fetch-status'. The description does not mention any alternatives or conditions, so an agent may not know that this tool is for lightweight robots.txt inspection (e.g., for compliance or quick checks) versus a full fetch.

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

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

The description mentions 'Key discarded' and the schema notes several parameters are 'discarded after the check', which is a behavioral disclosure. However, with no annotations, the description carries the full burden, and it fails to explain what 'shape check' means, what constitutes a valid Jira key, or what the tool returns. The mismatch between the stated purpose and the 9-parameter schema 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 extremely short (two sentences), which is concise, but it omits critical information. The 'Key discarded' phrase is repeated in the schema for multiple parameters, creating redundancy. The structure is front-loaded with the purpose, but the purpose is undermined by the schema mismatch.

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, no output schema, and a stated purpose that doesn't match the schema, the description is severely incomplete. An agent cannot determine which parameter to use for a Jira key, what the tool returns, or how it relates to sibling shape-checking tools. The description provides almost no useful context for correct invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. However, the description adds no parameter-level meaning beyond the schema, and the schema itself is confusing: none of the 9 parameters (ref, url, city, feed, host, json, path, zone, query) relate to a Jira issue key. The description's 'Key discarded' doesn't map to any parameter named 'key'. The description fails to compensate for the schema's apparent mismatch with 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 says 'Check a Jira issue key shape' but the input schema has 9 unrelated parameters (city, feed, host, json, path, zone, query, etc.) with no Jira key parameter. The verb 'Check' and resource 'Jira issue key shape' are clear, but the schema contradicts the stated purpose, making it misleading for an agent trying to select this tool.

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 on when to use this tool vs alternatives. The description doesn't mention any conditions, exclusions, or alternatives. The sibling list includes domain-shape, github-repo-shape, figma-url-shape, and wiki-title-ok, which are similar shape-checking tools, but no differentiation is provided.

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

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

The description reveals only that the body is discarded, which is a useful side-effect detail, but it says nothing about auth, rate limits, error cases, or behavior when multiple of the 9 params are supplied. Since annotations are absent, this small disclosure is not enough to carry the transparency burden.

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

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

The text is short and front-loaded, but it is too thin for a tool with 9 optional parameters and no required parameters. It reads as under-specified rather than concise; one sentence cannot cover the decision space implied by the schema.

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

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

Given the 9-parameter schema and no annotations or output schema, the description must explain how the params relate to the tool behavior. It only mentions one URL flavor, leaves the other eight parameters unaddressed, and never states what output the agent will receive besides 'HTTP status'. Zero guidance on output, errors, or the meaning of 'discarded after the call' makes this highly incomplete.

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

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

Although each parameter has a schema description (e.g., 'City name for a public weather hint; discarded after the call'), the tool-level description ties only 'url' to the stated purpose agenda; the many unrelated params are listed without explaining how they relate to 'HTTP status for a public library docs URL'. The schema descriptions help individual params but fail to clarify which param drives the tool or how to use the optional params.

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

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

The description names a concrete action ('HTTP status for a public library docs URL') but the actual input schema accepts nine unrelated optional fields (city, zone, json, query, host, path), so the stated purpose does not match the tool's apparent surface. It gives no sense of which parameter drives the behavior or what the returned status refers to.

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 siblings such as fetch-status or browser-url-ok, and no exclusions or preconditions. With 9 optional parameters and a one-line description, the agent is left to guess which inputs are relevant and which are ignored.

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

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

No annotations are provided, so the description carries the full burden. It discloses that values are discarded, which is good, and explains that the JSON input is read-only. However, it doesn't specify if the tool accesses any external state (e.g., memory storage) or if it has side effects. Given the large schema with many parameters that are noted as 'discarded', the description does hint at a read-only nature but could be more explicit.

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

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

The description is extremely concise: one sentence. It front-loads the core action. However, it is so terse that it sacrifices utility for brevity, falling short of what a richer description could provide.

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, 0 required, no output schema—the description is insufficient. It does not clarify the return format, how the count is returned, what happens with invalid JSON, or how the other parameters relate to 'memory'. The description is far from complete for an agent to use 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 each parameter is described, but many descriptions are just 'discarded after X', which adds little meaning beyond the schema. The description text itself does not elaborate on the 'json' parameter, which is central to the tool's purpose. It adds minimal value over the schema since most parameters are irrelevant to the tool's named function.

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 ('Count') and resource ('keys in a JSON object'), and highlights that values are discarded. However, the tool name 'memory-key-count' is vague and the description lacks clarity on what 'memory' refers to—it likely relates to workspace memory, not just any JSON object. It does not distinguish itself from 'validate-json' or 'domain-shape' siblings, which also operate on JSON-like structures.

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

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

The description provides no guidance on when to use this tool over others. Given the long list of sibling tools with overlapping purposes (e.g., validate-json, domain-shape), the lack of any when-to-use or when-not-to-use instructions leaves an agent guessing. It does not mention prerequisites or alternatives.

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

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

With no annotations, the description carries the full burden and does disclose the key transformation behavior: it drops query and fragment components, implying a read-only normalization. However, it never explains how the obviously unrelated parameters (ref, city, json, zone, feed) are treated, whether they are ignored, and what an invalid URL produces.

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 zero filler: the verb, the output components, and the transformation rule all appear immediately. There is no wasted text.

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

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

For a nine-parameter, zero-required tool with no output schema or annotations, this short description is insufficient. It leaves unexplained what happens when only city or zone is passed, whether the other parameters are decoys, and what a return value would look like, so an agent cannot confidently 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 coverage is 100%, so the baseline of 3 applies and the description adds little beyond the schema. The description's 'host' and 'path' terms could be confused with the schema's host and path parameters, which describe different semantics ('Public hostname' and 'File path to check'), and the description never states that the only meaningful input is the url parameter.

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

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

The description names a specific verb and resource ('Return origin, host, and path for a URL') and adds a distinctive behavior ('Query and fragment are dropped'), which clearly distinguishes the core operation from generic fetching. It does not explicitly differentiate itself from siblings like browser-url-ok or web-fetch, and the nine-parameter schema full of unrelated inputs (city, feed, zone, json) slightly muddies what the tool actually works on.

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

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

No guidance is given on when to call this tool versus alternatives, nor does it mention which sibling handles availability checks, shape checks, or fetching. There are no preconditions, exclusions, or offered examples of when normalization is preferred, leaving the agent to guess.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. The description says 'Query text discarded' on a few parameters, implying side effects or lack thereof, but it is inconsistent: some parameters say 'discarded' (ref, city, feed, json, query) while others do not (url, host, path, zone). This is contradictory and opaque. It does not state whether the tool performs network I/O, has side effects, or what 'Find' results mean.

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 fairly short, but it is not well-structured. It front-loads the purpose ('Find a living people-search index'), but then includes a vague list of outputs ('CLI setup, docs, API, and remote MCP hops') that is not helpful. The phrase 'Query text discarded' is repeated in the parameter descriptions, which is redundant. Overall, it is concise but not effective.

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 output schema, and no annotations, the description is severely inadequate. It does not explain how the tool works, what inputs are required (though none are mandatory), what the return value looks like, or how parameters like 'city' or 'feed' relate to the purpose. An agent cannot safely call this tool without risking unintended behavior.

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

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

Despite 100% schema description coverage, the description does not add meaning beyond the parameter descriptions. It only lists the parameters in the main description, but that is redundant. The description hints at 'discarded' for some parameters, but it does not explain how each parameter is used or what the expected input format is beyond the schema's basic types. The tool has 9 parameters and zero required, so more clarity would be 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 verb ('Find') and resource ('living people-search index (Ploid)'), but the purpose is obscured by the odd list of behaviors: 'Returns CLI setup, docs, API, and remote MCP hops.' This does not clearly explain what the tool actually does or what the input parameters are for. It is not a tautology, but it is confusing and fails to distinguish from similar index tools like 'agent-tool-index'.

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 provided on when to use this tool versus alternatives. The description does not mention any conditions for use, nor does it name any sibling tools. The 'Query text discarded' hint suggests it might be a health check, but that is not explicit. With 29 siblings, this lack of routing information leaves an agent guessing.

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 only states 'No browser is launched,' which is a negative constraint. It does not disclose what happens with the many parameters (many are discarded), whether there are side effects, permissions, or what the return value looks like. This is a significant gap for a tool with 9 parameters.

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

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

The description is very concise, just one sentence, and front-loaded with the core action. However, it is so brief that it lacks any structured detail about the tool's breadth of inputs or behavior. It is efficient but under-specified for the tool's complexity.

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 and no output schema, yet the description only explains a single capability (checking URL openability) without explaining how the diverse parameters (city, json, path, etc.) relate to that purpose. An agent cannot fully understand the tool's scope or when to invoke it from this 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?

Schema description coverage is 100%, so each parameter is described in the schema (e.g., 'Git ref name; discarded after the shape check'). The tool description itself adds no information about parameters, but since the schema already documents them thoroughly, 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 states a specific action: 'Check whether a URL can be opened' and adds a key behavioral note 'No browser is launched.' This distinguishes it from browser-url-ok, which likely does launch a browser. It is clear on the primary purpose, though it doesn't mention the wide variety of input 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 provides no guidance on when to use this tool versus alternatives like normalize-url, web-fetch, or browser-url-ok. It does not state conditions, exclusions, or mention any sibling tools. An agent has to infer usage from the name and schema.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does state 'Query discarded,' which informs the agent that the input is not persisted, but it does not describe what the tool returns, how the count is computed, or whether the other eight schema parameters are ignored.

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

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

The description is two short, front-loaded sentences with no wasted words. However, given the unusually broad nine-parameter schema, the brevity borders on under-specification, so it earns a 4 rather than a 5.

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

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

The tool has nine optional parameters and no output schema, yet the description does not clarify which parameter is actually used, what the return value looks like, or whether the other parameters are irrelevant. An agent could reasonably wonder whether to pass ref, city, json, or other fields, making this a significant completeness gap.

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

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

Schema description coverage is 100%, so the schema already documents every parameter. The description adds little beyond what the query parameter's own schema description already says ('discarded after the length check'), so the baseline of 3 is appropriate.

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

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

The description states a specific operation ('count characters') and a specific target ('a search query'), making the core purpose clear. It does not explicitly differentiate from sibling count tools like memory-key-count or hn-front-count, but the 'search query' scope gives enough distinction for a 4.

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

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

There is no guidance on when to use this tool versus alternatives, and no mention of exclusions or prerequisites. The only implied context is that it handles search queries, but sibling tools like memory-key-count and hn-front-count are 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Short catalog' and does not mention output shape, side effects, network/disk access, or how the parameters relate to behavior. The schema hints that several inputs are discarded, but the description itself discloses nothing.

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

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

The text is short, but this is under-specification rather than skillful conciseness. A single phrase does not adequately support a 9-parameter tool with no output schema and no usage guidance, so the brevity sacrifices essential information.

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

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

For a tool with 9 optional parameters, no annotations, no output schema, and a large sibling set, this description is severely incomplete. It fails to explain the request/response contract, the role of each parameter, or how this tool differs from status-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 description coverage is 100%, so each parameter already has an individual description, meeting the baseline. However, the tool description adds no meaning tying parameters like city, zone, or query to the stated purpose of cataloging HTTP status codes.

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

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

The description is essentially a noun phrase that restates the tool name: 'Short catalog' closely mirrors 'status-catalog'. It adds that the domain is HTTP status codes, but it lacks a verb indicating what the tool does (look up a code, list codes, validate a status?), and the 9 unrelated input parameters further obscure the purpose.

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

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

No guidance is given on when to use this tool versus siblings like fetch-status or browser-url-ok. There is no mention of intended context, preconditions, or exclusions, so an agent has no basis for choosing or invoking it appropriately.

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

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

The description discloses a key behavioral trait: 'Prompt discarded.' This is useful because it tells the agent the input prompt is not retained. However, with no annotations, the description carries the full burden, and it doesn't disclose other behaviors like whether the template is static, whether it depends on any parameters, or what the output format 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 extremely concise: two short sentences. It front-loads the core purpose and adds a behavioral note. No wasted words, though it could arguably include a bit more context without becoming verbose.

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, the description is too thin. It doesn't explain how the parameters relate to the 'three-step thinking template,' whether any parameters are required for meaningful use, or what the return value looks like. An agent would struggle to know what to pass and what to expect.

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 9 parameters. The description adds no parameter-specific meaning beyond the schema. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description states a specific verb and resource: 'Return a three-step thinking template.' It also adds a notable behavioral note ('Prompt discarded'). However, it doesn't explicitly distinguish itself from the many sibling tools, though the unique 'thinking template' output makes it fairly distinct.

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 on when to use this tool versus alternatives. The description doesn't mention any context, prerequisites, or exclusions. The 'Prompt discarded' note hints at a side effect but doesn't help an agent decide when to invoke it.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It says what is returned conceptually but not what happens on an invalid/missing zone, whether live time is fetched, or which parameters actually affect the result. It does not contradict any annotation because none exist.

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

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

One short sentence with no filler or redundancy. The core idea is front-loaded and the wording is as compact as possible for the information it conveys.

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 required parameters, no output schema, and no annotations, this description is too thin. An agent cannot determine which parameter is operative, what happens if none are supplied, or what the response contains.

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

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

Schema description coverage is 100%, so the baseline is 3 despite no parameter detail in the tool description. The description adds only the IANA qualifier and does not clarify the purpose of the eight unrelated optional parameters.

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

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

The description names a specific resource ('named IANA timezone') and outcome ('current time'), making the basic purpose clear. It is distinguishable from utc-time and iana-zones even though it does not explicitly reference them.

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

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

There is no guidance on when to use this tool versus utc-time, iana-zones, or geo-hint. The IANA qualifier is the only implicit hint, and the description never states that zone is the relevant parameter while the other eight parameters are irrelevant.

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 doesn't mention that the tool accepts 9 parameters that are mostly discarded, nor does it explain what the output format looks like. The description is too minimal to convey the tool's actual behavior beyond returning a timestamp.

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

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

The description is extremely concise at just three words. It's front-loaded and to the point, though it may be too sparse to be genuinely helpful. It earns points for efficiency but loses some for not adding 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?

Given the tool has 9 parameters, no output schema, and no annotations, the description is inadequate. An agent cannot tell why the tool accepts parameters like 'ref', 'url', 'city', etc., or what the return value looks like. The description needs to explain that these parameters are accepted but ignored, and what the output format is.

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 9 parameters. The description adds no parameter-specific meaning, but the baseline of 3 applies because the schema does the heavy lifting. However, the description doesn't clarify why a UTC timestamp tool accepts parameters like 'city' or 'feed', which could confuse an agent.

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

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

The description 'Current UTC timestamp' clearly states the tool's purpose with a specific verb and resource. It distinguishes itself from the sibling 'timezone' tool, which likely deals with timezone conversions, while this tool simply returns the current UTC time.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'timezone' or 'iana-zones'. It doesn't mention that the tool accepts various parameters that are discarded, nor does it clarify that it's a simple utility for getting the current time.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does add one useful behavioral fact: 'The body is discarded,' implying no persistence or side effects. However, it omits return format, error behavior, and any other side effects, so transparency is only partial.

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

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

The description is two short sentences with no filler. The core action is front-loaded, and the discard behavior earns its place as an important side-effect note. It is appropriately minimal.

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

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

There is no output schema and no annotation, and the description does not state what the tool returns (e.g., a boolean, an Ok/error object). It also leaves ambiguity between 'body' and the 'json' parameter, and ignores the eight other parameters entirely. An agent could not fully predict invocation results from this 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?

Schema description coverage is 100%, so the baseline is 3. The description itself adds no parameter-level meaning: it does not clarify that the 'json' parameter is the 'body' it refers to, nor does it explain the many unrelated parameters. The schema already documents each parameter, so the description adds little beyond the baseline.

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

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

The description states a specific action ('Check whether a body is valid JSON') and a clear resource. It is clear about what the tool does, but it does not distinguish itself from sibling validation/shape tools such as domain-shape or jira-key-shape, so it misses the top score.

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

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

There is no guidance about when to use validate-json versus sibling tools, no mention of alternatives, and no exclusions or prerequisites. The only implicit signal is that this tool is for JSON validation, which is not enough to route an agent correctly among the many similar shape-check siblings.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states a simplistic 'current temperature' purpose. It fails to disclose that the tool likely performs various 'hint' checks (e.g., validates refs, URLs, JSON) and that most parameters are 'discarded after the check,' implying side-effect-free behavior. The description misleadingly implies a single-purpose weather tool when the schema indicates a multi-purpose validator.

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 brief (one sentence), which is concise, but it is under-specified for a tool with 9 parameters. It lacks structure and does not front-load the full scope of the tool. Being short is not a virtue when critical behavioral information is omitted.

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 optional parameters, no required parameters, no annotations, no output schema), the description is grossly inadequate. It does not explain the tool's polymorphic nature, which parameters are mutually exclusive, what checks are performed, or what the return value is. An agent would be lost trying to invoke this tool correctly beyond the weather 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?

Schema coverage is 100%, so each parameter is described in the schema, but the descriptions are terse (e.g., 'City name for a public weather hint; discarded after the call'). The tool description adds no additional parameter semantics beyond what the schema provides, and it even misses the opportunity to clarify which parameter is the primary one for the stated purpose. Baseline 3 is appropriate because the schema covers everything, but the description adds no extra 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 clear verb and resource ('Current temperature for a city via Open-Meteo'), which distinguishes it from many siblings. However, it does not mention that the tool appears to be a generic 'hint' checker that also validates various inputs (ref, url, json, etc.), which is misleading about its actual purpose. The description is too narrow relative to the schema, which suggests the tool does much more than weather.

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 schema shows 9 optional parameters covering diverse checks (URL, JSON, timezone, search query), but the description only mentions weather, leaving the agent with no clue which parameter to use for which task or how to choose among siblings like 'geo-hint' or 'validate-json'. No when/when-not guidance is provided.

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

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

No annotations exist, so the description must carry the full burden. The description discloses 'Body discarded', which is a genuine behavioral detail, and specifies 'public URL' as a constraint. However, it does not reveal behavior around redirects, failures, timeouts, or response format, leaving important gaps.

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

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

The description is extremely concise with no wasted words. The primary function is front-loaded and the behavioral point about the body is the only extra. Its brevity is not a flaw here, though it does contribute to the low contextual 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 optional parameters, many of which seem unrelated to the described behavior, this description is insufficient. It does not explain how the parameters map to the stated function, what to pass for a successful call, or what the output shape looks like. The lack of output schema and annotations makes the missing context even more impactful.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-specific meaning beyond the schema, and the schema itself already explains that many parameters are discarded. No contradiction, but the tool description fails to clarify which parameter is relevant for the main URL action.

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: obtain HTTP status and content type for a URL, and discards the body, which is a specific resource. However, it does not differentiate from the sibling tool 'fetch-status', which likely has the same purpose, so it stops short of a 5.

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

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

No explicit guidance on when to use this tool over alternatives like fetch-status or browser-url-ok. The line 'Body discarded' implies the use case (need status/content type only), but no when/when-not or alternative comparisons 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, the description must carry the behavioral burden, but it only says 'Title discarded after the call' while no title parameter exists. It does not disclose output values, error behavior, side effects, or what 'exists' means. No annotation contradiction occurs because annotations are absent.

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 the main claim is front-loaded, but it is under-specified for a nine-parameter tool. The second sentence refers to a nonexistent title parameter and therefore does not earn its place.

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

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

For a tool with nine unannotated parameters and no output schema, this description is far too incomplete: it does not say which parameter to provide, what result the agent will receive, or how this tool differs from the many sibling validators.

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 adds no useful parameter meaning; it invents a title input absent from the schema. This active mismatch with the provided properties lowers the score below the schema-coverage 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 'Check whether a Wikipedia title exists,' but the input schema exposes no title parameter—only ref, url, city, feed, host, json, path, zone, and query. This mismatch makes the stated purpose misleading rather than clarifying.

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 instead of siblings like normalize-url, validate-json, rfc-number-ok, or search-query-len. Worse, the only purpose it suggests (Wikipedia title check) cannot be mapped to any available parameter, so an agent cannot select or invoke it correctly.

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