ISO country NE

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

With no annotations, the description carries the behavioral disclosure burden. It does disclose one trait (input task text is discarded) and implies a read-only lookup via 'Find' and 'Returns,' but it never states whether the call incurs network access, costs, or authentication requirements, especially given 'remote MCP hops' and 'pay-per-call.'

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

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

The description is short, front-loaded with the primary purpose, and each sentence serves a function: identify the resource, list the outputs, warn that task text is ignored. It is not padded, though the cryptic 'Task text discarded' could be clearer.

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

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

The tool has 9 optional parameters, no output schema, and no annotations, so the description must explain what inputs matter and what happens when invoked; it does not. It leaves an agent unable to determine why it would pass url, city, feed, host, json, path, zone, query, or ref, or whether a bare invocation is valid.

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

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

Schema description coverage is 100%, so the baseline is 3 and the schema already explains each parameter. The description adds no extra parameter meaning and even creates confusion by saying 'Task text discarded' while no task/text parameter exists in a schema with additionalProperties false.

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

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

The description names a specific action ('Find a public pay-per-call tool gateway (Monid)') and the concrete artifacts it returns (CLI setup, how-it-works, skill file, remote MCP hops), so it is not a tautology. However, 'Monid', 'tool gateway', and 'remote MCP hops' are unexplained jargon, and the phrase does not distinguish this tool from the many sibling lookup/probe 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 only usage hint is the implicit scenario of needing a Monid gateway and the note that 'Task text discarded.' There is no explicit when-to-use/alternatives guidance, no exclusion criteria, and no indication how this should be selected over sibling tools such as web-fetch or citation.

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 supplied, the description carries the full burden of behavioral disclosure. It discloses only that no browser is launched; it does not say whether the tool makes a network request, performs a syntax/shape check, has side effects, or what it returns. This is insufficient for a check tool with no output schema.

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

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

The description is two short sentences with no padding, front-loading the core purpose and adding a useful constraint. It is appropriately terse, though the terseness contributes to the behavioral under-specification scored elsewhere.

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

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

For a tool with 9 parameters, no annotations, and no output schema, this one-line description is not complete. It fails to explain the return value, the nature of the check, how parameters beyond url relate to the tool, or when to use it. The only definite context is the no-browser guarantee.

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 and even notes that most are discarded. The prose description adds no parameter-level meaning, and the url parameter's schema wording ('normalize or cite') does not clearly connect to 'can be opened', but the high schema coverage earns the baseline 3.

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

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

The description names a clear action and target: checking whether a URL can be opened, and it adds a key qualifier ('No browser is launched') that separates it from playwright-url-ok. It does not specify what 'can be opened' means (HTTP reachability, URL syntax, or DNS resolution), so it is slightly ambiguous.

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

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

The phrase 'No browser is launched' implies the tool is a lighter-weight alternative to browser-based checks like playwright-url-ok, but it never says when to choose this tool over fetch-status, normalize-url, or web-fetch. Usage guidance is only implicit, not explicit.

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

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

With no annotations, the description carries the full burden of explaining behavior, but it only says 'Expression discarded.' It does not state whether the tool returns a result, whether it mutates state, what side effects occur, or what happens to the nine accepted parameters. 'Discarded' is vague and unsupported by the schema.

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

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

The description is short and front-loaded, but it is under-specified: 'Expression discarded' is cryptic and does not earn its place for a tool with nine parameters. Being brief is not helpful when the brevity hides the actual contract.

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 severely incomplete. It does not explain return values, errors, parameter selection, or any side effects, and it cannot be used 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?

The schema provides descriptions for all 9 parameters, so the 100% coverage baseline applies. The description adds no parameter-level meaning and instead references an 'expression' that does not exist among the parameters, which slightly undermines trust but does not reduce what the schema already documents.

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 claims the tool evaluates 'a+b style arithmetic', but the input schema exposes nine unrelated string parameters (ref, url, city, feed, host, json, path, query) and contains no expression parameter. An agent therefore cannot tell what this tool actually does or how to invoke it for the stated purpose. The phrase 'Expression discarded' is ambiguous about whether a result is even returned.

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

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

The description gives no when-to-use or when-not-to-use guidance and does not compare against sibling validators such as file-path-ok or validate-json. It only implies an arithmetic use case that the schema does not support, leaving an agent without actionable selection criteria.

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

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

With no annotations, the description carries the behavioral burden. It does disclose one important trait: 'Page content is not stored.' However, it does not mention network behavior, redirects, rate limits, or what happens to the seven input parameters, leaving several behavioral aspects implicit.

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

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

The description is two short sentences with no filler; the core output is front-loaded and the non-storage guarantee is a worthwhile second sentence. It is as concise as possible for the information it provides.

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 seven optional parameters, no output schema, no annotations, and a cluster of sibling URL tools, this description is too sparse. It doesn't explain which parameters to pass, the return shape, or how this choice differs from fetch-status/web-fetch, so an agent has incomplete 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 coverage is 100%, so the schema already documents each parameter, earning a baseline of 3. The description adds no mapping between the stated URL behavior and the many non-URL params (ref, city, feed, json, path), though their schema descriptions do say they are discarded.

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

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

The description uses a specific verb ('Return') and names a concrete resource: host, scheme, and HTTP status for a URL. It is clear enough to identify the core operation, but it does not explicitly contrast with sibling URL tools such as fetch-status or normalize-url, so differentiation is left to inference.

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 rather than the many related siblings (fetch-status, web-fetch, normalize-url, browser-url-ok). 'For a URL' gives context but no exclusions, alternatives, or prerequisite conditions, so an agent cannot reliably choose it among similar 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?

The description explicitly states 'No identifiers are retained,' which is a useful behavioral and privacy guarantee, and 'Show' implies a non-mutating, informational operation. However, with no annotations provided, the description carries the full burden and does not disclose whether the tool makes network calls, what side effects occur, or how values are handled beyond the schema's own 'discarded' notes.

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

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

The description is two short sentences with no filler. The primary action is front-loaded and the privacy note is relevant and economical.

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 the description does not explain what the classification response looks like, what classification buckets exist, or how the tool should be invoked meaningfully. The parameter schema is complete, but the tool's overall behavior and return value remain underspecified for a 9-parameter meta-tool.

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

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

Schema description coverage is 100%, so every parameter is already documented with meaningful descriptions. The tool description itself adds no parameter-level semantics, so the baseline of 3 applies.

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

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

The description states a clear action ('Show how this request is classified'), but it does not define what classification means, what categories exist, or what 'this request' refers to. It is not a tautology, but it is vague and does not differentiate the tool from its many sibling validators and checkers.

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

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

The description gives no guidance about when to use compatibility versus any sibling tool. It does not mention alternatives, exclusions, or a concrete scenario in which the tool should be selected. With 26 siblings, this lack of usage direction is a significant gap.

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

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

With no annotations, the description carries the behavioral burden. It does clearly identify a pure string-splitting operation and explicitly excludes WHOIS/ownership enrichment, which is the main behavioral caveat. However, it does not state whether network access occurs or explain how the many non-hostname parameters behave, though the schema's per-parameter 'discarded' notes partially compensate.

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, readable sentence with no filler. It is front-loaded with the core action and boundary, though it is arguably too terse given the complexity and ambiguity of the input 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?

A nine-parameter tool with no annotations and no output schema needs more than a one-sentence hostname description. The definition does not explain why unrelated parameters are accepted, how to choose among sibling tools, or what the full set of behaviors is. This leaves significant gaps for an agent deciding whether and how to invoke the tool.

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

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

Schema description coverage is 100%, so the parameters are already documented individually. The description adds some clarity by identifying hostname as the central concept, but it does not explain the relationship among the nine parameters or which parameter should be used in which context.

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

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

The description states a specific verb and resource: 'Split a hostname into labels' and adds a useful boundary ('without WHOIS or ownership data'). It is clear about the core domain operation, though the nine-parameter input schema suggests a broader or shared shape-checking behavior that the description does not acknowledge.

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 positive guidance on when to use this tool versus alternatives. The phrase 'without WHOIS or ownership data' is only a negative exclusion. The description also does not clarify which of the nine optional parameters should be supplied or why fields like city, feed, json, query, and zone appear in the 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 and does disclose the method (HEAD), the scope (public URL), and the limited return value. But the input schema exposes many optional parameters (city, path, json, etc.) whose relationship to the HEAD call is unexplained, and redirect/error behavior is not covered.

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

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

A single, front-loaded sentence with no filler. Every word earns its place and the core action is immediately clear.

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

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

For a tool with no output schema, no annotations, and 9 optional parameters, the description is thin: it does not specify the exact format of the returned status, does not state that `url` is effectively required despite the schema listing 0 required parameters, and does not say what happens if multiple parameters are supplied. Still, the common 'HEAD a URL' path is reasonably clear.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds the key clue that `url` is the actual target of the HEAD request, but it does not clarify why the other eight optional parameters exist or whether url is effectively required.

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

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

The description uses a specific verb ('HEAD'), names the resource ('public URL'), and specifies the narrow output ('status only'). This clearly distinguishes it from content-fetching siblings like web-fetch and from boolean URL checks like browser-url-ok.

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

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

It clearly implies the tool is for when only an HTTP status is needed, not page content. However, it does not explicitly name alternatives or state when not to use it, so it stops short of the top score.

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

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

There are no annotations, so the description carries the full burden of explaining behavior. It discloses one trait ('Path discarded') but leaves unclear what the tool returns, whether it validates, normalizes, extracts fields, or makes external calls. This is minimal disclosure for a tool with no annotation safety net.

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 appropriately short and front-loaded with the main verb and resource. It earns its words, though the second phrase 'Path discarded' is terse to the point of ambiguity.

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 9-parameter schema, no output schema, and no annotations, this two-phrase description is not enough for an agent to confidently invoke the tool. It does not say which parameter to pass, what result to expect, or how to handle the unrelated parameter names.

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

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

The input schema has 100% description coverage, so the schema itself documents all nine parameters. The description adds no meaningful parameter semantics beyond repeating the 'path discarded' idea, and it does not clarify why the schema includes many unrelated parameters (city, feed, json, zone, query).

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

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

The description states a specific verb ('Parse') and a specific resource ('a Figma file URL'), so the core purpose is clear. However, 'Path discarded' is ambiguous and the description does not explicitly distinguish this from sibling URL-related tools like normalize-url or browser-url-ok.

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

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

The description implies usage: call this tool when you need to parse a Figma file URL. It gives no explicit alternatives, exclusions, or guidance on when a sibling tool would be more appropriate, so it only meets the 'implied usage' level.

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

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

With no annotations provided, the description carries the behavioral burden and does disclose a key trait: no disk access, meaning it does not check filesystem existence or permissions. However, it fails to define 'safe', state the return type, or describe error and edge-case behavior, leaving meaningful ambiguity.

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

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

Two sentences, zero filler. The core action is front-loaded, and the 'No disk access' clarification earns its place by preventing a common misassumption.

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

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

The tool has no output schema, no annotations, nine optional parameters, and many sibling validators. The description is too thin to be complete: it does not explain expected output, the safety criteria, or how the unrelated optional parameters should be handled. This is a notable gap for a predicate-style tool.

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

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

Schema description coverage is 100%, so each parameter already has explanatory text. The tool description adds no parameter-level meaning and does not clarify why the schema also accepts ref, url, city, feed, host, json, zone, and query while the description only mentions a path. This matches the baseline for high schema coverage.

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

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

The description clearly identifies the operation and resource: checking whether a path looks safe. The added 'No disk access' also sets it apart from file-system-touching tools, though it does not explicitly name sibling alternatives or define what 'safe' means.

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

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

There is no explicit when-to-use or when-not-to-use guidance. The description hints at a syntactic check with 'No disk access', but it does not direct the agent away from sibling tools like normalize-url, domain-shape, or browser-url-ok, leaving usage selection to inference.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only names the data source. It does not mention whether the call is read-only, that external network access is needed, that inputs are discarded, or what happens on failure.

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 concise with no filler, and the core result is front-loaded. However, it is a fragment rather than a complete instruction, and it is under-specified for a tool with nine parameters and no behavioral annotations.

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

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

For a tool with no output schema, no annotations, nine optional parameters, and many sibling tools, a one-line description is insufficient. The agent cannot confidently determine which parameter to supply, what the return structure looks like, or how this tool relates to weather-hint and other hint tools.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no mapping between the concept of 'a place' and the nine optional parameters, and it does not clarify that city is likely the relevant input, so the agent must rely on the schema descriptions.

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

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

The description states that the tool provides latitude and longitude for a place via Open-Meteo, which is fairly clear about the core output. It is not a complete instruction and does not explicitly name the input, but the purpose is not vague.

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

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

There is no guidance about when to use geo-hint versus weather-hint, timezone, or the many other sibling tools. No conditions, exclusions, or alternatives are mentioned, leaving the agent to infer usage from the name and context alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that the tool parses owner and repo, but does not disclose what happens for invalid or non-GitHub URLs, whether it returns parsed values or only validates shape, or whether any input is discarded during processing. This is a significant transparency gap.

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

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

The description is a single, front-loaded sentence with no wasted words. It quickly conveys the core purpose without repeating the tool name or padding.

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

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

Despite the simple wording, the tool has 9 optional parameters, no annotations, and no output schema. The description does not specify which parameter should contain the GitHub URL, what the parsed owner/repo output looks like, or how errors are handled, so an agent would likely need additional information to invoke it confidently.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning beyond naming the GitHub URL context, but the schema already documents each parameter, including 'discarded' behavior for several of them.

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

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

The description uses a specific verb and resource: 'Parse owner and repo from a GitHub URL.' This clearly distinguishes the tool from sibling shape tools like domain-shape, figma-url-shape, and jira-key-shape, which target different input kinds.

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

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

The description implies the tool should be used when an agent has a GitHub URL and needs owner/repo extracted, but it provides no explicit when-to-use conditions, exclusions, or references to alternative tools such as normalize-url or domain-shape. Usage guidance is left to inference.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals only that titles are discarded and the snapshot is current, but it does not state the return type, whether a network request occurs, or how failures are handled.

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

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

The description is terse and front-loaded with no filler. It loses one point because 'Titles discarded' is cryptic and would be clearer if tied to the output 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?

With nine optional parameters, no annotations, and no output schema, a two-sentence description is insufficient. The agent does not know what input to provide if any, what the tool returns, or what happens to the passed values, leaving the definition incomplete for confident invocation.

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

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

Schema description coverage is 100%, so the schema already documents every parameter. The description itself adds no parameter-specific meaning, which meets the baseline, but it never clarifies which of the nine optional parameters, if any, are relevant to counting Hacker News front-page stories.

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

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

The description states a specific verb and resource: 'Count current Hacker News front-page stories.' It also adds a distinguishing behavioral detail, 'Titles discarded,' which helps separate it from generic fetch or read 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 provides no explicit guidance on when to use this tool versus alternatives, and it names no exclusions or prerequisites. The only usage signal is implied by the purpose itself, so the agent must infer when a front-page count is needed.

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

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

With no annotations, the description carries the full burden, but 'Common IANA timezone names for clock calls' reveals no behavior. It does not mention output format, whether this is a static list, side effects, or that several inputs are discarded.

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

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

The description is a single short phrase with no filler, but it is under-specified rather than concise. It lacks a verb and gives no structural guidance on how to invoke the tool.

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

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

For a tool with no output schema, no annotations, and nine parameters, this description is incomplete. It does not explain what the tool returns, how the parameters relate to IANA zones, or that many parameters are discarded.

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; all parameters have their own descriptions. The tool description adds no parameter meaning, but the schema already documents each parameter.

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

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

The description identifies a resource (IANA timezone names) and a domain (clock calls), so it is not a tautology. However, it lacks an action verb like 'lists' or 'returns', and does not differentiate from sibling tools such as 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' implies a timezone-related context, but there is no explicit guidance on when to use iana-zones versus timezone, utc-time, or other siblings. No alternatives or exclusions 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses that this is a public fetch and that only group counts are returned, but it does not explain network behavior, failure modes, redirect handling, or what happens when no robots.txt exists.

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

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

The description is a single front-loaded sentence with no filler. It efficiently states the action, the resource, and the output restriction.

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

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

With nine optional parameters, no output schema, no annotations, and an ambiguous mapping between parameters and the robots.txt task, the bare one-sentence description is not enough for an agent to reliably invoke the tool. It lacks parameter selection guidance, return-value details, and error 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?

Although schema description coverage is 100%, the parameter descriptions are generic and not tied to robots.txt. An agent cannot tell from the schema or description whether to pass 'host', 'url', or 'path' to identify the target, and fields like 'city', 'feed', and 'json' appear irrelevant to the tool's stated purpose.

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

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

The description names a specific verb and resource ('Fetch a public robots.txt') and a precise output ('return group counts only'). This clearly distinguishes it from sibling tools like web-fetch or fetch-status, which would return full content or status rather than summarized group counts.

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

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

The description gives no guidance about when to choose this tool over alternatives such as web-fetch, normalize-url, or domain-shape. It does not mention what input should be provided or when the tool should not be used.

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

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

There are no annotations, so the description must carry the full behavioral burden. 'Key discarded' hints that the tool is non-persistent and probably side-effect-free, but it does not disclose what the tool returns (e.g., a boolean, normalized key, error message) or any consistency guarantees. The behavioral detail is extremely thin.

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

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

The description is only two sentences and is very brief, which is good for conciseness. However, the brevity comes at the cost of clarity, and the second sentence 'Key discarded' adds little actionable information. The structure is acceptable but the content is too sparse to be genuinely helpful.

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

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

Given no annotations, no output schema, and a parameter schema that is clearly misaligned with the tool purpose, the description is far from complete. An agent lacks even the most basic information needed to call the tool: which parameter carries the Jira key, what the response looks like, and what 'shape check' actually entails. The sibling list reinforces the shape-checking category but does not compensate for these missing details.

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

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

The schema lists seven parameters, none of which is named 'key' or explicitly described as a Jira issue key. The description says 'Key discarded,' but the agent cannot determine which schema field to populate. The schema property descriptions are about unrelated concepts like Git refs, URLs, city names, and JSON text, so they do not help map the intended input. This is a serious gap that makes correct invocation nearly impossible for 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 states a specific verb ('Check') and resource ('a Jira issue key shape'), making the tool's core purpose immediately clear. It is distinct from the sibling shape-checking tools because it explicitly names Jira. However, it does not explicitly differentiate itself from closely related tools like github-repo-shape or domain-shape, 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?

The description provides no guidance on when to use this tool versus alternatives. With a sibling list full of similar shape-checking utilities, an agent is left to infer from the tool name that this is the Jira-specific shape checker. No exclusions, prerequisites, or alternative routing are mentioned.

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

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

The description discloses a meaningful behavioral trait: the body is discarded, so the caller should only expect status. Since no annotations are provided, the description carries the transparency burden, but it does not mention redirect handling, timeouts, or the fact that the large set of extra parameters appears to be 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 sentences, front-loaded with the main purpose and immediately followed by the key limitation ('Body discarded'). Every word earns its place; there is no filler or redundancy.

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

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

With nine parameters, no annotations, and no output schema, the description is too thin to be fully actionable. It does not explain how to select among the many parameters, what the output format looks like beyond 'HTTP status', or how this tool relates to the large sibling family of URL/status/shape tools.

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

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

Although the input schema has 100% description coverage, the tool description does not clarify which parameter is the relevant one, and the schema's 'url' description ('HTTPS URL to normalize or cite') conflicts with the stated purpose of returning HTTP status. This leaves an agent uncertain about how to map the description onto the parameter set.

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

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

The description clearly states the tool returns an HTTP status for a specific kind of resource ('public library docs URL') and adds that the body is discarded. It is specific enough to convey the core action, but it does not differentiate this from sibling tools like fetch-status or browser-url-ok.

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

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

The intended use case is implied: call this when you need a quick HTTP status check for a public library docs URL and do not need the response body. However, there are no explicit alternatives, exclusions, or guidance about when to prefer a sibling tool such as fetch-status or web-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?

With no annotations, the description carries the behavior burden; 'Values discarded' is a useful disclosure that the tool ignores value content. But it does not say whether the count is distinct keys, nested keys, or just top-level, nor does it describe side effects or the return format.

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

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

The description is two short sentences with no filler; the core operation is front-loaded and the 'Values discarded' qualifier earns its place by communicating a meaningful behavioral trait.

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

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

This tool has multiple optional parameters, no output schema, and no annotations. The description does not explain the return value, how the JSON object is supplied, or how nested objects are handled, leaving a material gap for an agent attempting 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%, but the schema descriptions do not support the described purpose: 'json' is described as 'JSON text to validate', not as the object whose keys are counted, and the other parameters look unrelated. The description adds no mapping from 'a JSON object' to an input parameter, so an agent cannot confidently choose the right argument.

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

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

The description names a specific operation ('Count keys') and a specific resource ('a JSON object'), and adds that values are discarded, which distinguishes the tool from value-oriented JSON tools like validate-json. It is not a tautology, but it does not explicitly position the tool against its siblings.

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

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

The use case is implied: call this when you need to know how many keys a JSON object has and do not care about its values. However, there is no explicit statement of when not to use it or which sibling alternative, such as validate-json, might be preferable.

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

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

With no annotations, the description carries the behavioral burden. It does disclose a meaningful behavior—query and fragment are dropped—and implies a read-only transformation. However, it does not state the output shape, behavior for invalid URLs, whether other accepted parameters are ignored, or whether the operation is local versus network-based.

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 core behavior is front-loaded. Every word contributes to the stated transformation.

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

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

The tool has nine optional parameters, no annotations, no output schema, and many sibling tools, yet the description provides only the core behavior. It does not identify which parameter is required, how the result is structured, or how to distinguish this tool from related siblings, leaving significant gaps 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 and the description does not need to restate parameter meanings. The description adds a useful detail about URL query/fragment dropping, but it also creates confusion because the description's `path` and `query` refer to URL components, not the schema's `path` (file path) and `query` (search text) parameters.

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

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

The description states a specific operation—return origin, host, and path for a URL, dropping query and fragment—so it is not tautological. However, the input schema exposes nine unrelated optional parameters and includes `path` and `query` as inputs, which collide with the description's output terms. With zero required parameters, an agent cannot confidently determine which parameter actually supplies the URL.

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

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

The description implies the tool is for extracting origin/host/path from a URL, but it gives no explicit when-to-use or when-not-to-use guidance. It names no alternatives, even though many sibling tools such as `domain-shape`, `browser-url-ok`, and `web-fetch` overlap with URL-related tasks.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It explicitly states that no browser is launched, which is a useful non-obvious behavior. However, it does not disclose whether a network request is made, what counts as 'openable', or what the output looks like.

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

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

The description is two short sentences with no filler. The core purpose is front-loaded, and the behavioral caveat follows immediately. Every word earns its place.

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

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

Despite good schema coverage, the description leaves important gaps: there is no output schema, no definition of the success/failure criteria, and no guidance on how to use 9 optional parameters with zero required. An agent would likely need to infer the calling contract and return format.

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

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

The schema descriptions cover 100% of the parameters, so the baseline applies. The free-text description adds no parameter-level detail and does not clarify which of the 9 optional parameters should be supplied for the URL check, though the schema itself is fairly descriptive.

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 meaningful qualifier ('No browser is launched') that helps distinguish it from browser-based alternatives. However, 'can be opened' is left somewhat ambiguous—it does not define whether this means HTTP reachability, URL parseability, or something else.

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

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

The description implies a lightweight, browserless URL check but does not explicitly say when to prefer this over sibling tools like browser-url-ok or fetch-status. The 'No browser is launched' sentence offers a hint, but there is no clear routing or alternatives 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?

With no annotations, the description must carry the behavioral burden. It does disclose that the query is discarded, which is useful, but it never states what the tool returns, how characters are counted, or how the other parameters are treated.

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 main intent is front-loaded. Every word contributes to the core meaning.

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

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

Given nine parameters, no annotations, and no output schema, the description is too thin to fully guide an agent. It omits the return format, the relationship between the description and the query parameter, and what happens with the other eight inputs.

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

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

All parameters already have schema descriptions, so the baseline applies. The tool description adds no parameter-level detail beyond echoing the 'query' concept and does not clarify which of the many inputs should actually be provided.

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

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

The description clearly states the action and resource: 'Count characters in a search query.' This is more specific than the tool name alone, but it does not distinguish this from sibling count-related tools such as memory-key-count or hn-front-count.

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

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

There is no guidance about when to use this tool versus alternatives, no prerequisites, and no exclusions. The intended use is only implied: measure the length of a search query.

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 explaining side effects, read-only behavior, or discard semantics. It only says 'catalog' and does not mention that inputs are discarded after shape checks or that no state is changed.

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

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

The description is a single short sentence with no filler, but the brevity leaves out critical usage and behavioral context. It is under-specified rather than appropriately concise for a tool with seven 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?

With seven schema parameters, no output schema, and no annotations, a one-phrase description is completely inadequate. It does not explain how the parameters map to the catalog, what the output looks like, or what 'common HTTP status codes' means in relation to the inputs.

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

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

The schema descriptions cover all parameters, so the schema already provides the heavy lifting. The tool description adds no parameter-level meaning or relationship between the parameters and the catalog.

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

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

The description identifies a resource ('common HTTP status codes') and hints at a lookup/catalog behavior, but uses no verb and is vague about what the tool actually does with the inputs. It does not differentiate from siblings like fetch-status or web-fetch.

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

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

No guidance is given on when to use this tool versus sibling tools such as fetch-status, normalize-url, or web-fetch. There are no exclusions, conditions, or alternative recommendations.

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

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

With no annotations, the description carries the burden. 'Prompt discarded' is a useful behavioral disclosure, but the description doesn't clarify whether the eight input parameters affect the result, what side effects exist, or what the returned template contains.

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

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

Two short sentences communicate the core operation and a key behavioral caveat. The description is front-loaded and contains no filler.

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

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

Despite a simple-sounding purpose, the tool has eight optional-looking parameters and no output schema, and the description doesn't explain how they relate to the template or when the tool should be invoked. An agent would still have to guess why the parameters exist.

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 fully documents all eight parameters with individual descriptions, so the description need not repeat them. The description adds no parameter-specific meaning, meriting the baseline for high schema coverage.

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

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

The description states a specific action and output: 'Return a three-step thinking template.' This clearly identifies the tool's purpose and distinguishes it from the domain-checking sibling tools, though it doesn't explain what the template is for.

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

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

There is no guidance about when to use this tool versus any sibling. The only usage hint is 'Prompt discarded', which tells the agent not to expect custom prompt processing, but no conditions or exclusions are stated.

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

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

With no annotations, the description carries the behavioral burden. It states the core read-only lookup behavior, and 'current time' implies no mutation, but it does not mention output format, handling of invalid timezone names, or whether this is a network call. The behavior is simple, but some detail is missing.

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

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

The description is one short, front-loaded sentence with no filler. Every word earns its place, and it is easy to scan.

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 definition is adequate for a simple tool, but with no output schema and several seemingly unrelated parameters in the input schema, the description does not clarify what the return value looks like or confirm that 'zone' is the operative parameter. The schema helps, but the description leaves some context to inference.

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

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

Schema description coverage is 100%, so the parameter meanings are already documented, especially the 'zone' parameter described as 'IANA timezone name.' The description reinforces the IANA concept but does not add syntax, format, or usage details beyond the schema.

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

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

The description clearly identifies the resource and result: current time for an IANA timezone. It is easy to distinguish from related tools like utc-time or iana-zones, though it lacks an explicit verb such as 'returns' and does not explicitly name sibling alternatives.

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

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

There is no guidance about when to use this tool versus alternatives like utc-time or iana-zones. The intended use is only implied by the phrase 'current time in a named IANA timezone,' with no exclusions, prerequisites, or alternative routing.

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

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

With no annotations present, the description must carry the behavioral disclosure burden. It does not mention that the many accepted parameters are discarded or irrelevant, nor does it specify the output format. The schema hints at discarding, but the description itself adds no behavioral transparency.

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

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

The description is a single short sentence with no wasted words, making it highly concise and front-loaded. However, it is so minimal that it omits important usage context, so it is not a perfect score.

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

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

Despite the tool being conceptually simple, the 7-parameter schema and lack of output schema make the description incomplete. It does not clarify the output format, whether arguments are ever meaningful, or how this tool relates to the timezone sibling. An agent could call it, but with avoidable uncertainty.

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

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

The input schema provides descriptions for all seven parameters, so schema coverage is effectively 100%. The description adds no parameter-level information, but the baseline of 3 applies because the schema already documents each parameter's role.

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 identifies that the tool returns the current UTC time, and this distinguishes it from siblings like timezone or iana-zones. It lacks an explicit verb like 'returns', but the resource and intent are unambiguous.

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

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

There is no guidance about when to use this tool versus alternatives such as timezone or when to pass parameters. The description does not state that all inputs are optional or ignored, leaving the agent to infer usage from the schema.

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

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

There are no annotations, so the description carries the full disclosure burden. It does add a useful non-obvious behavior: the body is discarded. However, it does not say what happens with invalid JSON, what the return value is, or whether any side effects occur.

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

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

The description is only two short sentences, with the core action front-loaded and no filler. Both sentences earn their place.

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

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

With no output schema and no annotations, the description should clarify what the caller receives (e.g., a boolean or error) and which parameter is the body. The unusual multi-property schema makes the missing routing guidance expensive: an agent could guess the wrong parameter.

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

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

All seven parameters have descriptions in the input schema, so the description need not repeat them. The word 'body' is loose and does not clearly map to the `json` property, but the schema already documents that `json` is the JSON text to validate.

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

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

The description clearly states the action ('check whether a body is valid JSON') and the subject, which is enough to distinguish it from the URL/path-shaped validators in the sibling list. It does not explicitly contrast itself with any sibling, 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?

No guidance is given about when to use this tool versus sibling validation/shape tools, nor are any prerequisites or exclusions mentioned. The intended use case is only implied by the tool name and the single sentence.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It mentions the external service, but does not state that only the city parameter is used, that other parameters are ignored, whether network calls are made live, or what happens on failure. Too much is left undisclosed.

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 sentence conveys the core function without filler. The most important information, the tool's purpose and data source, is immediately front-loaded.

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

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

The tool has nine optional parameters, no output schema, and no annotations, yet the description only states the basic purpose. It does not explain which parameter to use, how to handle the irrelevant parameters, or what the response looks like, making it insufficient for confident invocation in ambiguous situations.

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 already documents all parameters and their discard behavior. The description adds the key connection between city and temperature, but does not clarify why the other eight unrelated parameters exist or whether they affect the weather lookup.

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

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

The description clearly states the tool returns current temperature for a city via Open-Meteo, giving a specific output, resource, and data source. It is distinguishable from siblings like timezone or geo-hint, though it does not explicitly differentiate itself from weather-related alternatives.

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

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

There is no guidance on when to use this tool versus alternatives such as web-fetch or geo-hint. No context, exclusions, or selection criteria are provided, leaving the agent to infer applicability.

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

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

With no annotations, the description carries the behavioral disclosure burden. It explicitly states that the body is discarded and that only status/content type are returned, which is a meaningful behavioral constraint. It does not cover redirects, timeouts, or output format, but the core side-effect limitation is disclosed.

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

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

The description is two short sentences with no filler. It front-loads the purpose and then adds the critical behavioral constraint ('Body discarded'). Every word earns its place.

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

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

Given the tool has 9 schema parameters and many close sibling tools, the description is too sparse to be complete. It does not explain the role of the non-URL parameters, how results are returned, or how this tool differs from fetch-status and other URL-checking siblings. The basic purpose is clear, but an agent cannot confidently select or invoke the tool across all relevant situations.

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 tool description adds no parameter-level detail, but the baseline for high schema coverage is 3. The description also does not clarify why many unrelated-looking optional parameters exist in the schema, though this is not required at 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 clearly states the tool reports 'HTTP status and content type for a public URL' and adds that the body is discarded. Although it lacks an explicit verb like 'fetch', the resource and observable result are clear enough. It does not explicitly distinguish itself from the sibling 'fetch-status' 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 is provided on when to use web-fetch versus alternatives such as fetch-status, browser-url-ok, or playwright-url-ok. The phrase 'Body discarded' implies it is not for content extraction, but no explicit when-to-use or when-not-to-use guidance is given.

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 that the title is discarded after the call, which is a useful privacy trait beyond the schema. However, with no annotations present, the description carries the full burden for behavioral disclosure. It does not mention whether the tool makes a network request, whether it returns a boolean, or how it handles invalid or missing input, leaving some important behaviors unspecified.

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

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

The description is extremely concise—two short sentences, both substantive. The purpose is stated first, and the data-handling note follows without any filler. Every word earns its place, making this an exemplary minimalist 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?

For a simple existence-check tool, the description is mostly sufficient, but the generic 8-parameter schema could confuse an agent about which argument is relevant. The schema fills that gap for 'query', but the lack of an output schema means the return type is only implied. Given the low complexity, this is a minor gap, hence a mid-range score.

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% parameter description coverage, and one of those descriptions ('Query string for Wikipedia title lookup') directly maps to the tool's purpose. The main description adds no parameter-level information beyond what the schema already provides, so the baseline of 3 for high schema coverage 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 action ('Check') and a precise resource ('whether a Wikipedia title exists'), which is more specific than many sibling tools. It doesn't explicitly contrast with related validators like 'validate-json' or 'normalize-url', but the Wikipedia-title focus is enough to distinguish its core purpose.

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

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

There is no indication of when to use this tool versus alternatives, no exclusions, and no mention of conditions that would favor a sibling. The description is purely declarative and leaves usage decisions entirely to inference from the tool name and sibling list.

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