ISO country FM

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 adds one useful privacy detail ('Task text discarded'), but it omits side effects, external calls, rate/cost implications, auth needs, and what actually happens with the nine optional inputs.

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, and free of filler. Two sentences deliver the main action, the return contents, and a privacy-relevant note without waste.

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

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

For a tool with nine optional parameters, no output schema, and no annotations, this description is too sparse. It lists outputs but does not explain invocation context, parameter relationships, or edge/failure behavior, making it insufficient for reliable agent selection and use.

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

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

Schema description coverage is 100%, so the schema already documents each parameter in isolation. The description adds no extra meaning about how the nine optional parameters should be chosen or how they map to the returned artifacts.

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 target ('public pay-per-call tool gateway (Monid)') and lists the delivered outputs: CLI setup, how-it-works, skill file, and remote MCP hops. It is clear about the resource and action, though it does not explicitly differentiate the tool from 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?

There is no guidance on when to use this tool versus the many sibling tools, and no exclusions or prerequisite conditions are stated. Usage context is only weakly implied by the phrase 'Find a public pay-per-call tool gateway'.

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 disclosure burden. It does disclose one meaningful behavior—no browser is launched—but it remains silent on whether the check performs a network request, whether it has side effects, or what error/return behavior to expect. This is partial transparency, not full.

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 tight sentences with the primary purpose first and a useful behavioral caveat second. There is no filler, repetition, or unnecessary detail.

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

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

Given no output schema, no annotations, and 9 optional parameters, the description is too thin to be fully actionable. It does not explain what the tool returns, which parameter(s) should be used for the URL check, or what 'can be opened' means in observable terms. The concise phrasing helps clarity but not completeness.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the tool description itself adds no parameter-level insight. The description also fails to map the general 'URL can be opened' purpose onto the 'url' parameter, whose schema description instead says 'normalize or cite', leaving some ambiguity about which parameter is central.

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

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

The description states a concrete action ('Check whether a URL can be opened') and a clear resource, with the caveat 'No browser is launched' helping differentiate it from browser-based sibling tools like playwright-url-ok. However, it does not define what 'can be opened' means—HTTP reachability, rendering, or URL 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 'No browser is launched' clause implies this is a lightweight check and distinguishes it from browser-automation tools, but the description never explicitly says when to prefer this tool over alternatives like fetch-status, web-fetch, or playwright-url-ok. Usage context must be inferred rather than stated.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that the expression is 'discarded,' which is a small behavioral clue, but it does not state what the tool returns, whether it mutates anything, what errors occur, or why unrelated schema parameters are involved.

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

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

The description is extremely short and front-loaded with the core verb and object. Both sentences are compact, though the second sentence is ambiguous and the overall brevity sacrifices needed 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?

For a tool with 9 parameters, no annotations, and no output schema, this description is severely incomplete. It does not explain which parameter carries the arithmetic expression, what evaluation result is returned, or how this tool relates to the sibling validation tools. An agent cannot safely or correctly invoke it based on this definition.

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

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

Schema description coverage is 100%, so the input schema already documents all nine parameters in detail. The description adds no parameter-level meaning and, in fact, introduces an 'arithmetic expression' concept that no schema parameter represents, so the baseline 3 is appropriate.

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

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

The description names a verb and resource: 'Evaluate a+b style arithmetic.' However, the input schema contains no arithmetic expression parameter and instead lists unrelated fields like URL, city, feed, JSON, and host, so the stated purpose does not map to the actual invocation surface. It also does not distinguish this tool from sibling shape/validation tools.

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

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

No guidance is given about when to use this tool versus any sibling like domain-shape, validate-json, or browser-url-ok. The phrase 'Expression discarded' hints at behavior but provides no usable decision rule or context for selecting this tool.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. 'Page content is not stored' is a useful privacy trait that goes beyond the schema, and 'return ... HTTP status' implies a read-only network check. However, it does not disclose whether the URL itself is retained, whether redirects are followed, or whether the optional schema inputs have 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?

Two sentences with no filler: the first front-loads the operation and return values, and the second adds a relevant privacy caveat. Every word earns its place.

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

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

The core call path is understandable: provide a URL and receive host, scheme, and status, with page content not stored. But the tool has a large, permissive input schema, no output schema, and no usage guidance, so the description leaves ambiguity about the optional parameters and how this tool relates to overlapping siblings.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description adds little parameter-level detail. The phrase 'for a URL' usefully identifies url as the primary input, but the description does not clarify formats or the roles of optional parameters like ref, city, feed, host, json, and path beyond what the schema already says.

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

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

The description states a specific output ('host, scheme, and HTTP status') for a specific resource ('a URL'), so an agent knows what the tool does. It doesn't, however, draw any contrast with closely related siblings such as fetch-status or normalize-url, so it stops short of full differentiation.

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

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

The description offers no guidance on when to use citation rather than fetch-status, normalize-url, web-fetch, or browser-url-ok. There is no mention of exclusions, prerequisites, or alternative tools, so an agent must infer the right context from the tool name and output description.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does add a meaningful privacy trait: 'No identifiers are retained,' and several schema fields repeat the discard behavior. However, it does not disclose the output format, side effects, or whether any network/request activity occurs.

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

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

The description is two short sentences with no filler. The main action is front-loaded, and the privacy note earns its place. It is appropriately sized for what 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 nine optional parameters, no output schema, no annotations, and no sibling differentiation, the description is too thin. It does not explain what 'classification' means, what the response looks like, which parameter combinations are valid, or how an agent should invoke it. Privacy is addressed, but operational completeness is not.

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 beyond the schema; it reinforces non-retention but does not clarify which of the nine optional fields are relevant or how they influence 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 uses a clear verb 'Show' and names the resource 'how this request is classified', but 'classified' is undefined: there is no mention of classification categories, criteria, or output form. It also does not differentiate this tool from sibling shape/check tools such as domain-shape or validate-json.

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

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

There is no guidance about when to use this tool versus the many sibling tools. The description does not state when to prefer compatibility, what inputs make it appropriate, or any exclusions. Usage context is only weakly implied by the generic 'this request' phrasing.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose that the operation is purely syntactic and does not perform WHOIS or ownership lookups, which is useful. However, it does not mention that many of the 9 schema parameters appear to be discarded or ignored for this tool, nor does it describe the return format or error behavior.

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

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

The description is a single, front-loaded sentence with no filler. It states the primary action, the resource, and a key limitation efficiently. 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 optional parameters, no output schema, and no annotations, the description is too sparse to be fully actionable. It does not specify which parameter to pass, whether other parameters are ignored, or what the output will look like beyond the vague notion of 'labels.' An agent would need additional inference or documentation to invoke it reliably.

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

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

Schema description coverage is 100%, so the schema already documents each parameter, including 'host' as 'Public hostname.' The description adds only the concept of splitting the hostname into labels, which is useful but minimal. It does not clarify whether the 'host' parameter is the sole relevant input or how the other parameters should be treated.

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,' which makes the core purpose clear and distinguishes it from sibling tools like github-repo-shape or normalize-url. The added 'without WHOIS or ownership data' clarifies scope. However, it does not explicitly name or contrast any sibling tool, and the broad 9-parameter input schema creates some ambiguity about which input is actually relevant.

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 normalize-url, browser-url-ok, or github-repo-shape. The phrase 'without WHOIS or ownership data' implies a limitation but does not provide explicit when-to-use or when-not-to-use conditions. An agent is left to infer the appropriate context from the tool name and description 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, the description carries the behavioral burden. It does disclose the HTTP method (HEAD), the public scope, and that only status is returned, which is meaningful. However, it does not mention redirects, timeouts, error handling, rate limits, or why the schema accepts many non-URL parameters that are described as 'discarded.'

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

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

The description is a single sentence with no filler: it front-loads the operation and the output. Every word earns its place, and the structure is immediately scannable for an agent.

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 output schema, and no annotations, yet the description only covers a single HEAD request. The return format is not described, and the existence of unrelated-looking parameters like 'city' and 'json' is unexplained, leaving an agent unable to fully predict behavior.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds the useful hint that 'url' is the key parameter, but it does not help an agent understand the purpose or interaction of the other eight optional parameters, such as ref, city, feed, or json.

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 ('HEAD a public URL') and the expected output ('return status only'), so the basic purpose is clear. However, it does not name or differentiate itself from sibling URL-checking tools like browser-url-ok, playwright-url-ok, or web-fetch, and the broad input schema suggests a wider scope than the one-sentence description implies.

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 browser-url-ok or web-fetch. The only implied constraint is 'public URL,' but there are no explicit exclusions, no alternative tool names, and no conditions that would route an agent to a sibling tool.

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

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

With no annotations, the description is the sole source of behavioral detail. It discloses one non-obvious behavior (path is discarded), but omits whether the tool fetches, validates, returns a boolean or normalized URL, or what happens with malformed input.

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

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

Two short sentences, front-loaded with the core purpose and no filler. It is compact, but the second fragment is cryptic enough that some of its brevity is under-specification rather than efficient clarity.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, this description is incomplete: an agent cannot tell what the tool returns, which parameter to populate, or whether using it has side effects. The single behavioral note is insufficient context.

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

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

Schema description coverage is 100%, so the baseline is a 3; the description adds 'Path discarded,' which is redundant with the path property's own 'discarded after the call.' It does not map the Figma URL to the url property or clarify why the schema contains many apparently 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?

States a concrete operation (parse) on a specific resource (Figma file URL), and the name plus 'Path discarded' signal a shape-check utility distinct from sibling validators like github-repo-shape or jira-key-shape. It stops short of saying it validates shape or returns a match result, so it earns a 4 rather than 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 gives no when-to-use direction, no exclusions, and does not name alternatives such as normalize-url or browser-url-ok. The only conditional hint is 'Path discarded,' which doesn't tell an agent when to choose this tool over sibling shape checkers.

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. 'No disk access' is a useful behavioral disclosure indicating a purely syntactic, side-effect-free check. However, it does not define what 'safe' means, what conditions are checked (e.g., path traversal, null bytes), or what the return value looks like.

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

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

The description is two short sentences with no filler. It front-loads the core action ('Check whether a path looks safe') and then adds the critical side-effect boundary ('No disk access'). Every word earns its place.

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

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

The tool has no annotations, no output schema, and a nine-parameter input schema that includes many seemingly unrelated fields. The description does not explain what 'safe' means, which parameter to supply, what the return value is, or how to handle the extra schema fields, leaving an agent to guess.

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

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

Schema description coverage is 100%, so the baseline is 3 even without parameter details in the description. The description refers to 'a path' but does not explicitly map to the `path` parameter among nine optional fields, nor does it clarify that the other fields are irrelevant to this tool.

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

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

The description states a clear verb and resource: 'Check whether a path looks safe.' It also adds 'No disk access,' which distinguishes it from actual filesystem operations. However, 'safe' is left undefined and no sibling differentiation is provided, so it stops short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives such as browser-url-ok, normalize-url, or fetch-status. The description does not state when-not-to-use it or mention sibling tools. The only implicit hint is 'No disk access,' which is not enough to route an agent.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It only mentions that Open-Meteo is involved, hinting at an external dependency, but it does not explain rate limits, expected latency, side effects, or that most schema parameters are 'discarded' after checks. The schema descriptions reveal discarding behavior, but the description itself does not.

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

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

The description is a single focused sentence with no filler or repetition. It front-loads the core purpose in eleven words. However, given the complexity of the nine-parameter schema, the brevity borders on under-specification rather than useful conciseness.

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

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

The tool has nine optional parameters, no output schema, and no annotations, yet the description does not explain which parameter to pass for a place, what the return value looks like, or how errors are reported. The schema descriptions are detailed but oddly describe most parameters as 'discarded' or for validation, adding confusion rather than resolving the gap. An agent would struggle to invoke this tool correctly with the provided information.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters in detail. The description does not add parameter-level meaning, such as which parameter represents the 'place' or how latitude and longitude are returned. Baseline 3 is appropriate because the description is not required to restate the schema, but it also does not help map the purpose to the 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 clear geocoding purpose: obtaining latitude and longitude for a place via Open-Meteo. It identifies the resource (a place) and the provider (Open-Meteo), which distinguishes it from some siblings. However, it lacks an explicit verb like 'Get' or 'Return' and does not connect the purpose to the tool's unusually broad input schema.

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

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

No guidance is provided about when to use geo-hint versus alternatives such as weather-hint, timezone, or other geolocation-related tools. The description gives no context about prerequisites, typical use cases, or exclusions. An agent would have to infer usage solely from the schema and tool name.

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

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

No annotations are provided, so the description carries the behavioral burden. The verb 'parse' implies a read-only extraction operation, which is useful, but the description does not disclose behavior for invalid/non-GitHub URLs, whether normalization occurs, or that the many other parameters 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, front-loaded sentence with no filler. It is appropriately concise for the core task, though it is short enough that it leaves other dimensions under-specified.

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

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

With no annotations, no output schema, and nine optional parameters, a one-sentence description is not complete. The description explains the central action but leaves return shape, error handling, invalid input behavior, and the role of the other parameters unexplained.

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

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

All parameters already have schema descriptions (100% coverage), so the baseline is met. The tool description adds no extra parameter-level meaning, and it does not explicitly state that 'url' is the relevant parameter for the GitHub parse while the rest are irrelevant or 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 specific verb and resource: parse owner and repo from a GitHub URL. This clearly distinguishes it from sibling shape tools like figma-url-shape, jira-key-shape, and domain-shape by naming both the GitHub context and the exact extracted fields.

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 this tool versus alternatives such as normalize-url, browser-url-ok, or other shape tools. There are no explicit exclusions, prerequisites, or routing hints; the only implied usage is the mention of a GitHub URL.

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 does disclose that titles are discarded and that the count reflects the current front page. However, it does not mention whether a live network fetch is involved, what failure modes exist, or what the exact return structure is, leaving partial 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 extremely concise: two short sentences with the core action front-loaded and a clarifying exclusion following it. Every word earns its place; there is no filler or repetition.

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

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

For a simple count tool, the core information is present, but the 9 optional parameters create ambiguity. In particular, the 'feed' parameter's description ('titles discarded') could mislead an agent into thinking a feed URL is the input source. The description does not clarify that no arguments are needed or how parameters affect the result, and with no output schema there remains some uncertainty about the 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?

Schema description coverage is 100%, so the baseline is 3 even without parameter-level detail in the tool description. The description adds no parameter semantics, but the schema already documents each parameter's purpose and that it is discarded, so the description does not need to compensate.

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

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

The description uses a specific verb and resource: 'Count current Hacker News front-page stories.' It clearly names what the tool does and distinguished it from all sibling tools, none of which perform this task. 'Titles discarded' further clarifies that the output is a count rather than a list of story titles.

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

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

The description implies the use case: an agent should call this tool when it needs the number of current Hacker News front-page stories. 'Titles discarded' is an implicit warning not to use it when titles are needed, but no alternatives are named and no explicit when-not conditions 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 carries the full transparency burden. It implies a static reference of common names but does not disclose the return format, whether the tool is read-only, or that all supplied parameters are discarded as the schema indicates.

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 words. It is front-loaded with the central topic, though it is a noun phrase rather than a complete sentence and could be more informative without losing concision.

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

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

The tool has no output schema or annotations, so the description should explain what the call returns and how to invoke it. It does neither, and the nine optional parameters with 'discarded' descriptions make the tool's contract confusing rather than self-evident.

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 a description, so the baseline is 3 even though the description adds no parameter information. The parameter descriptions are detailed but unrelated to IANA zones, so the description does not clarify why an agent would pass any 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 identifies the tool as a source of common IANA timezone names for clock calls, which conveys the domain and differentiates it from actual timezone conversion tools like timezone and utc-time. However, it lacks a verb such as 'returns' or 'lists', leaving it ambiguous whether the tool produces a list, validates a name, or does 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?

No usage guidance is provided. The phrase 'for clock calls' hints at the context, but the description never states when to call this tool instead of timezone/utc-time or how it relates to the sibling tools.

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

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

No annotations are provided, so the description carries the full burden. It does reveal that the output is limited to group counts, but it does not disclose behavior around missing robots.txt files, redirects, timeouts, rate limits, or whether any state changes occur. The description is too thin to provide a reliable behavioral profile.

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

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

The description is a single sentence with no filler. The action, resource, and output constraint are all front-loaded, making it easy to parse quickly.

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

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

With no output schema, no annotations, and nine optional parameters including seemingly unrelated fields like city, ref, feed, and json, the description is not sufficient for an agent to invoke the tool reliably. It does not explain which parameter to supply, what 'group counts' means precisely, or what happens when no robots.txt is found.

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 does not map 'public robots.txt' to any specific parameter, and schema descriptions like 'HTTPS URL to normalize or cite' and 'Public hostname' are generic. The description adds purpose but not parameter-level clarity.

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

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

The description states a specific verb and resource: 'Fetch a public robots.txt' with a precise output constraint: 'return group counts only.' This clearly distinguishes it from generic fetch tools like web-fetch or fetch-status, which would return full content or status rather than robots.txt 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?

There is no guidance about when to use this tool versus alternatives. The description does not mention conditions, exclusions, or sibling tools, despite the presence of many related fetch/URL tools in the sibling list. An agent must infer when a robots.txt group-count result is the right choice.

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

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

No annotations are provided, so the description carries the full burden. 'Key discarded' hints that the input is not retained, but the definition says nothing about the return value, side effects, or whether validation is local or 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 only eight words, with the purpose front-loaded and no filler. The brevity is efficient, though it edges into under-specification.

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

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

With a 7-entry schema, no output schema, no annotations, and a description that never maps a parameter to the Jira key input, the definition is not actionable. A tool cannot be invoked correctly from this information.

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

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

The schema describes seven unrelated inputs (ref, url, city, feed, host, json, path), none of which is labeled as the Jira key and none is connected to the tool's stated purpose. The description adds no parameter-level guidance, leaving an agent unable to determine which property to populate.

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 first sentence states a specific verb ('Check') and resource ('Jira issue key shape'), and the tool name reinforces the target. It is distinguishable from sibling shape checkers like domain-shape and github-repo-shape, though it does not say which input carries the key.

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, no exclusions, and no mention of alternatives among the sibling shape tools. The intended use case is only implied by the name and the first sentence.

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

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

With no annotations, the description must carry the behavioral burden. It usefully discloses that the body is discarded, which tells the agent only the status is relevant. It does not mention whether a real network request happens, redirect/auth behavior, or the exact form of the returned status.

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 sentence, no filler, and the core behavior is front-loaded. 'HTTP status' and 'Body discarded' are both high-signal statements, so 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?

The tool has no output schema, no annotations, and nine optional parameters, yet the description leaves the invocation under-specified. An agent is not told which field to set, what the returned status looks like, or what happens on invalid input. This requires too much guessing.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds a modest 'public library docs URL' hint that maps loosely to the url parameter, but the schema's own url description points to normalize-or-cite behavior. The description does not explicitly say to populate url and ignore the other eight optional fields.

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

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

The description states a clear action and resource: return the HTTP status for a public library docs URL. It even says the body is discarded, which narrows the output scope. However, it does not explicitly distinguish this from siblings like fetch-status, web-fetch, or browser-url-ok.

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

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

There is no guidance about when to use this tool versus any of the 26 sibling tools. The only implied usage is for public library docs URLs, but no exclusions or alternative routing are 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?

With no annotations, the description carries the full burden of behavioral disclosure. 'Values discarded' is a useful detail, but the description does not state whether counting is top-level or recursive, what happens with invalid JSON, or what response format the agent should expect. This is insufficient for a tool with zero annotation coverage.

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

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

Two short sentences with no filler; the core operation and a key behavioral trait are front-loaded. The brevity is efficient, though it leaves out important usage and behavior details.

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

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

For a tool with no output schema and no annotations, this definition is too thin. The agent must infer which of the many optional parameters to pass, whether nested keys are counted, how invalid JSON is handled, and what the return value looks like. This creates a significant gap for a seemingly simple 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 descriptions cover 100% of parameters, so the baseline is 3 even without additional description-level detail. However, the description does not map 'JSON object' to a specific parameter such as json, and the parameter descriptions focus on validation or shape checks rather than counting keys. The schema carries the parameter-level weight, but the missing linkage prevents a higher score.

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

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

States a specific action and target: 'Count keys in a JSON object.' The added phrase 'Values discarded' clarifies that values are irrelevant. However, it does not explicitly differentiate this tool from sibling validate-json or indicate which parameter supplies the JSON object, 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 guidance is given about when to use this tool versus siblings such as validate-json, search-query-len, or domain-shape. There are no prerequisites, exclusions, or examples, so the intended usage must be inferred entirely from the verb 'count.'

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

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

No annotations are present, so the description carries the behavioral burden. It does disclose a concrete behavior: query and fragment are dropped, and 'Return' implies a read-only normalization. However, it does not clarify which of the nine optional schema parameters actually affect behavior, nor any error handling or side-effect profile.

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, front-loaded with the return value followed by the drop behavior. Every sentence earns its place and there is no 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?

Given no output schema and no annotations, plus nine loosely related optional parameters, the description is too thin to fully contextualize a call. It names the output components but not their format, and it leaves the agent to guess that url is the only relevant parameter and what happens if other fields are supplied.

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 baseline is 3. The description adds little parameter-level meaning beyond the query/fragment drop and does not compensate for the confusing multi-purpose schema containing unrelated optional fields.

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

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

States a clear verb ('Return') and resource ('origin, host, and path for a URL') and specifies that query and fragment are dropped. However, it does not differentiate from sibling URL/shape tools like domain-shape, figma-url-shape, or browser-url-ok, so the agent cannot tell when this exact tool is preferred.

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

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

There is no explicit when-to-use or when-not-to-use guidance and no named alternatives. The intended use is implied: call this when you need the origin, host, and path of a URL. Given the many sibling tools, the lack of routing direction is a 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that no browser is launched, leaving unclear whether an HTTP request is made, whether this is purely a shape check, what is returned, and whether there are side effects. The schema's repeated 'discarded after the shape check' notes hint at validation-only behavior, but the description itself does not commit to that.

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 purpose, and includes an important caveat in the second sentence. Every word earns its place. It is slightly too terse for such a complex 9-parameter tool, but structurally it is crisp.

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 annotations, and no output schema, the description is not complete enough to guide correct invocation. It does not explain return values, side effects, network behavior, or how the many seemingly unrelated parameters (city, json, query, zone) relate to checking a URL. The description leaves the tool's actual contract ambiguous.

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 9 parameters are already fully described in the input schema, including 'discarded after' semantics. The tool description adds no parameter-level meaning, but because the schema covers all parameters, the baseline score 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 names a specific verb and resource: 'check whether a URL can be opened.' The added statement 'No browser is launched' helps distinguish it from browser-url-ok. However, 'can be opened' is somewhat ambiguous, since it could mean syntactic validity, HTTP accessibility, 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 gives no when-to-use guidance, no exclusions, and no mention of alternatives such as browser-url-ok, fetch-status, normalize-url, or web-fetch. The 'No browser is launched' clause hints at a contrast with browser-based checking, but it does not tell the agent when to choose this tool instead of another.

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

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

With no annotations provided, the description carries the transparency burden. It does disclose a meaningful behavioral trait: the query is discarded after the count. However, it does not state what the tool returns, how characters are counted, how missing or empty queries are handled, or whether there are any other 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 very concise and front-loaded: the core operation comes first, and the side effect follows in a second short sentence. Both sentences earn their place, though the brevity leaves important behavioral and selection details unstated.

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

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

Given nine optional parameters, no annotations, and no output schema, the description is too sparse. It does not explain return values, which parameter to populate, what happens if multiple parameters are supplied, or how the tool behaves when no query is provided, making it incomplete for reliable autonomous invocation.

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

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

Schema coverage is 100%, so each of the nine parameters already has a description; this earns the baseline 3. The tool description adds no additional meaning about which parameter is the search query or how the nine optional parameters relate, but the 'query' parameter's schema description aligns 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 clearly states the action ('Count characters') and the resource ('a search query'), so an agent can tell what the tool does. It doesn't explicitly differentiate itself from sibling count-type tools or mention the return value, but it is not tautological or misleading.

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 like memory-key-count or hn-front-count, and no mention of exclusions or prerequisites. The intended use is implied by the name and the phrase 'count characters in a search query', but the description leaves the selection decision entirely to inference.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not mention whether the tool performs any action, has side effects, requires permission, or returns data. The only behavioral hints appear in the input schema ('discarded after the shape check'), but the description neither confirms nor explains them, leaving the tool's behavior opaque.

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?

At six words, the description is technically concise but severely under-specified. It omits essential operational details, so the brevity is closer to under-specification than effective conciseness.

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

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

With seven input parameters, no annotations, and no output schema, the description is far from complete. It does not explain what the catalog contains, what inputs are expected for a lookup, what the return value is, or why this tool exists alongside related siblings like fetch-status and normalize-url.

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

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

The description makes no reference to any of the seven parameters. Although the schema includes per-parameter descriptions, they appear generic and unrelated to a status-code catalog (e.g., 'City name for a public weather hint'), creating a mismatch between inputs and purpose. The high schema coverage prevents a score of 1, but the description adds no semantic value and leaves parameter selection confusing.

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

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

The description identifies the resource ('Short catalog of common HTTP status codes') but provides no verb or operational action. It is vague because it does not state whether the tool lists, looks up, or validates status codes, and it does not distinguish itself from sibling tools such as fetch-status that also concern HTTP statuses.

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 or when to choose an alternative. The description lacks any context about use cases, prerequisites, exclusions, or comparisons 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It does disclose one behavior, that the prompt is discarded, and implies a read-only template return, but it does not explain what the template contains, whether any input affects the output, or any side effects or authentication requirements.

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

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

The description is exactly two short sentences, with the primary purpose front-loaded and no filler words. Every sentence contributes information: one states the return value, the other states the discarding behavior.

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

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

Given the unusually rich and unrelated input schema and the absence of an output schema, this description is too thin. An agent cannot determine what a 'three-step thinking template' looks like, whether parameters like url or city should be passed, or what happens if they are provided, so the tool is under-specified for its surface complexity.

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

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

The input schema provides high coverage with each parameter described in detail, so the baseline is 3. The description itself adds little parameter semantics beyond 'Prompt discarded,' which suggests the parameters may be ignored; that is a useful hint but does not clarify which parameter is expected or whether any are required.

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

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

The description opens with a specific action and object: 'Return a three-step thinking template,' which clearly states what the tool produces. The phrase 'Prompt discarded' further clarifies that it is a template generator, not a computational or analysis tool. However, the input schema lists many unrelated parameters (ref, url, city, feed, host, json, path), which muddies the purpose slightly and no sibling is explicitly contrasted.

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

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

No guidance is given about when to invoke this tool versus any of the sibling utilities, nor are there exclusions or alternative names. The only contextual hint is 'Prompt discarded,' which implies the caller does not need to supply meaningful prompt content, but this is not developed into a clear when-to-use/when-not-to-use statement.

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 conveys the core read-only behavior, returning the current time in an IANA timezone, but does not mention invalid inputs, missing zone behavior, or return format. This is acceptable for a simple lookup but minimal.

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 is concise, though slightly too terse to cover usage guidance or clarify which parameter matters.

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

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

The description plus the fully described schema parameters are minimally sufficient for an agent to call the tool with 'zone'. However, with nine optional parameters, no output schema, and no note about defaults or ignored parameters, there is still room for ambiguity.

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

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

Schema coverage is 100%, and the parameter descriptions already document that 'zone' is the IANA timezone name while other parameters are explicitly discarded. The top-level description adds little beyond the noun-phrase context, so it does not materially improve on 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 states a specific intent and resource: current time in a named IANA timezone. This is distinct from sibling tools like utc-time and iana-zones, so an agent can tell this tool apart without inspecting the schema.

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

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

There is no guidance about when to use this tool versus alternatives such as utc-time or iana-zones, and no exclusions or routing hints. The intended usage is only implicit in the purpose statement.

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

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

No annotations exist, so the description carries the behavioral disclosure burden. It does state the primary behavior—returning the current UTC time—and no destructive or stateful behavior is implied. However, it does not disclose output formatting, precision, or possible edge cases, leaving some behavioral detail unstated.

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 three-word phrase with no filler or redundant explanation. It is front-loaded and perfectly sized for a trivial timestamp utility.

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

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

The tool is simple and the schema descriptions clarify that the inputs are discarded, so an agent is unlikely to be confused about parameter effects. However, with no annotations and no output schema, the description does not state whether the returned timestamp is ISO 8601, Unix epoch, or what precision it uses. This is a clear but minor 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?

All seven parameters have descriptions in the input schema, including explicit notes such as 'discarded after the shape check,' so schema coverage is complete. The main description adds no additional parameter meaning, but the baseline score of 3 applies because the schema already documents the 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 'Current UTC timestamp.' clearly conveys that the tool returns the current UTC time. It is specific enough to be distinguished from sibling time-related tools like timezone and iana-zones, though it lacks an explicit verb.

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 normalize-url. The purpose implies it should be used when the current UTC timestamp is needed, but there are no explicit exclusions 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, the description carries more behavioral burden. It does disclose a meaningful trait in 'The body is discarded,' suggesting a read-only validation with no echo of the input. However, it does not state the return value, error behavior, or what happens on invalid JSON.

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

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

Two short sentences with no filler. The purpose is front-loaded, and the second sentence adds useful behavioral information rather than 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?

The tool has no annotations and no output schema, and the input schema contains several seemingly irrelevant parameters. The description does not specify the return shape, whether a parameter is required, or how this tool differs from sibling validators, leaving important operational ambiguity.

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 already describes all seven parameters, including the relevant `json` parameter, so schema coverage is high and the baseline is 3. The description adds no parameter-level meaning and does not identify `json` as the intended 'body' among the other unrelated-looking optional fields.

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

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

The description states a specific action and object: 'Check whether a body is valid JSON.' The tool name reinforces this. However, it does not explicitly differentiate from the many sibling check/shape tools, 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 use case is implied: an agent should call this when it needs to verify whether some JSON text is valid. But the description gives no explicit when-to-use or when-not-to-use guidance, and it does not mention alternatives among the sibling validation 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 full responsibility for behavioral disclosure, but it only names the data source. More seriously, the schema repeatedly states that parameters are 'discarded after the shape check' or 'discarded after the call,' while the description implies a real city-based weather lookup; this makes the actual behavior confusing and potentially misleading.

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, efficiently worded sentence with no filler. However, for a tool with nine parameters and no other documentation, this terseness borders on under-specification rather than ideal conciseness.

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

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

There is no output schema, no annotations, no return-format information, and no instruction on which of the nine optional parameters is actually used. The description is far too incomplete for an agent to invoke this tool correctly, especially with eight apparently unrelated parameters present.

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

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

Schema description coverage is 100%, so the baseline is 3; every parameter has some description. The tool description adds no parameter-level meaning and does not clarify that only the city parameter is relevant, but it also doesn't make the parameters worse than the schema already does.

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

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

The description states a concrete action and resource: returning the current temperature for a city via Open-Meteo. It is specific enough to distinguish weather-hint from location/geo siblings, though it doesn't explicitly call out any alternatives or scope limitations.

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, when not to use it, or which sibling tools to prefer. The input schema's nine optional parameters are not mapped to use cases, so an agent is left to infer that 'city' is the relevant input.

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 disclosure burden. It usefully discloses that only HTTP status and content type are returned and that the body is discarded, which prevents an agent from expecting page content. However, it does not mention whether a network request is made or how redirects, errors, timeouts, or rate limits behave, so important behavioral details remain 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?

The description is short and front-loaded, with the core result first and the body-discard caveat second. It contains no fluff, though the extreme brevity leaves some operational gaps.

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

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

For a tool with nine parameters, no output schema, no annotations, and a large sibling set, this terse description is not complete enough on its own. It does not describe return formatting, error behavior, or how the many possible inputs relate to the fetch, so an agent must rely heavily on schema details and 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?

The input schema already describes all nine parameters with 100% coverage, so the baseline is 3. The description adds little about the parameters themselves and highlights only the URL case, leaving the role of the other eight parameters underspecified by the description, though the schema compensates.

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 the deliverable as 'HTTP status and content type for a public URL' and notes the body is discarded, so an agent can tell it returns a lightweight fetch result rather than full page content. It lacks an explicit verb and does not position itself against siblings like fetch-status or normalize-url, so it is not 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 guidance is given for when to choose web-fetch instead of sibling tools such as fetch-status, browser-url-ok, or normalize-url. The only contextual signal is 'public URL,' which is too thin to route an agent reliably among the available 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?

The description discloses that the title is discarded after the call, which is a meaningful data-retention behavior. With no annotations present, the description carries the full burden, but it does not mention whether the check involves a live network request, response format, or failure behavior, so it offers only minimal behavioral context.

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

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

The description is concise and front-loaded with the main action, but it is drastically under-specified for a tool with a 7-property schema. The second sentence adds a behavioral note but not essential usage information, so the content is not appropriately sized.

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

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

With no annotations, no output schema, seven generic parameters, and many sibling tools, the description is far too thin. It does not explain which input to provide, what the tool returns, or how it differs from related validators, leaving the agent without the information needed to invoke it correctly.

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

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

The schema extensively documents its seven parameters, but the description's central subject, 'title', does not map to any of them. This active mismatch adds confusion rather than meaning, outweighing the baseline benefit of high schema description 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 ('Check whether a Wikipedia title exists'), but the input schema contains no 'title' parameter — it lists ref, url, city, feed, host, json, and path. This mismatch makes the tool's purpose misleading, as an agent cannot determine how to supply the title to check.

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

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

There is no guidance on when to use this tool versus the many sibling 'ok' tools (e.g., file-path-ok, browser-url-ok, fetch-status). No context, exclusions, or alternative suggestions are provided.

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