ISO country ML

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

No annotations are provided, so the description carries the burden. It does disclose a notable privacy behavior ('Task text discarded') and lists the output artifacts. However, it does not disclose whether invoking the tool itself has side effects, incurs cost, requires auth, or performs network calls; 'pay-per-call' hints at cost but is ambiguous.

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 front-loaded and the return contents plus the discard behavior stated with no filler. Every sentence 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 nine optional parameters, no output schema, and no annotations, the description is too sparse. It does not explain how any of the parameters affect the returned setup, what 'remote MCP hops' means, or whether arguments are even needed. An agent could select the tool based on the purpose statement, but would struggle to invoke it correctly.

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

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

Schema description coverage is 100%, so every parameter already has some documentation. The description adds no parameter-level meaning, and the phrase 'Task text discarded' refers to something not present in the schema. With all nine parameters optional, it remains unclear which parameter, if any, should be supplied.

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

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

The description names a specific action ('Find') and a specific resource ('public pay-per-call tool gateway (Monid)'), and it lists the return contents: CLI setup, how-it-works, skill file, and remote MCP hops. This is clear enough to distinguish it from the sibling shape/status checkers, though 'Monid' is unexplained and the connection to the input schema is unclear.

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

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

Usage is only implied: an agent would infer this tool is for locating or setting up the Monid gateway. There is no explicit statement of when to use it versus alternatives, no exclusions, and no guidance about how the many sibling tools relate to it.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose a meaningful behavior ('No browser is launched'), but it does not explain whether network requests are made, what 'opened' means, possible failure modes, or any side effects. 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 two short sentences with no wasted words. The core purpose is front-loaded, and the key 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?

The tool has nine heterogeneous parameters (url, city, json, path, query, etc.) and no output schema, yet the description only addresses a narrow 'URL can be opened' case. It does not explain how the other parameters fit into the tool's behavior, what the result format is, or when this tool should be selected over similar siblings. Significant information is missing for an agent to confidently invoke it.

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

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

Schema coverage is 100%, so the schema already documents all nine parameters. The description adds no parameter-level meaning, but it does not need to compensate given the schema's completeness. Baseline 3 applies.

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

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

The description clearly states the tool's function: checking whether a URL can be opened. It is a specific verb+resource statement, and the added phrase 'No browser is launched' distinguishes it from siblings like playwright-url-ok, though it does not name the alternative explicitly.

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 check ('No browser is launched') but provides no explicit when-to-use or when-not-to-use guidance, nor does it reference alternatives such as fetch-status or normalize-url. The usage context is inferable but not stated.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does say the expression is discarded, implying no persistence, but it does not explain whether a result is returned, whether any computation side effect occurs, or what an agent should expect after invocation. This is insufficient for a tool with a generic, nine-parameter 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 text is short and starts with the main action, which is structurally positive. However, the brevity omits essential information, and the second sentence, 'Expression discarded,' adds ambiguity without connecting to any schema field. The description is under-specified rather than appropriately concise.

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

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

For a tool with nine optional parameters, no required fields, no annotations, and no output schema, the description is far too incomplete. It does not say how to supply the expression, what a successful evaluation returns, what errors can occur, or any constraints. An agent cannot reliably invoke this tool from the definition alone.

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

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

Although the schema documents each parameter individually, the description references an 'expression' that has no corresponding field in the input schema. The actual parameters (ref, url, city, feed, host, json, path, query) are unrelated to arithmetic evaluation, and additionalProperties is false, so an agent cannot pass the expression the description advertises. This actively misleads parameter selection.

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

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

The description names a concrete resource and action: evaluating a+b style arithmetic. This distinguishes the tool from sibling shape/validation tools, but the phrase 'Expression discarded' is ambiguous about what the caller gets, and the schema has no expression parameter that matches the advertised purpose. The overall intent is visible but not fully reliable.

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 when-to-use guidance is given, no exclusions are stated, and no sibling alternatives are mentioned. An agent cannot tell when to choose calc-eval over validate-json, search-query-len, or the many other shape/check tools. Usage must be inferred entirely from the tool 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?

Without annotations, the description carries the behavioral burden. It adds a useful privacy-relevant behavior ('Page content is not stored') and implies an HTTP status check, but it does not disclose whether a network request is made, redirect/error behavior, or any rate limits.

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

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

Two short sentences, with the most important information front-loaded and no wasted words. The non-storage note earns its place as a behavioral clarification.

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 URL metadata tool, the key output fields are stated and the safety-relevant non-storage behavior is included. However, with no output schema or annotations and several overlapping siblings, the description could be more complete about return shape and when to pick this tool over fetch-status, normalize-url, or web-fetch.

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 has 100% property descriptions, so the baseline is 3. The description reinforces that a URL is the relevant input but does not clarify how the many optional parameters (ref, city, feed, host, json, path) relate to the tool; the schema covers them individually.

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

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

The description uses a specific verb ('Return') with a clear resource and output set: host, scheme, and HTTP status for a URL. It is unambiguous, but it does not explicitly distinguish itself from similar siblings such as normalize-url or fetch-status.

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

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

The phrase 'for a URL' gives implied context that this tool is for URL metadata lookup, and 'Page content is not stored' hints it is not for content retrieval. However, it provides no explicit when-to-use, when-not-to-use, or alternative tool guidance.

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

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

No annotations are provided, so the description must fully disclose behavior; it only adds the privacy statement 'No identifiers are retained.' It does not mention side effects, return format, error behavior, or how input values are handled beyond the discard statements already present in 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 a single short sentence followed by a privacy note, with no redundant words or filler. It is appropriately compact, though the brevity contributes to under-specification that is penalized 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?

With 9 optional parameters, no output schema, and no annotations, this one-sentence description is far too incomplete. It fails to explain what classification result is produced, how to choose among parameters, what values are valid, or what the response looks like, leaving an agent unable to use the tool 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%, with each of the 9 parameters documented in the input schema. The tool description itself adds no semantic detail beyond the schema, so the baseline score of 3 is appropriate; the schema fully carries parameter meaning.

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

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

The description says only 'Show how this request is classified,' which names a generic action and a vague resource without defining what 'classified' means or what 'compatibility' has to do with it. It does not state the output, the classification categories, or how it relates to the tool name. This is close to a tautology because the description restates the tool's action in equally ambiguous terms.

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 this tool versus any sibling tool. The description gives no conditions, examples, exclusions, or alternative tool names, and with 9 optional parameters and many shape-checking siblings, an agent cannot infer when this tool 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?

There are no annotations, so the description carries the full burden of disclosing behavior. It mentions one limitation, no WHOIS or ownership data, but says nothing about input validation, return format, error behavior, or that many schema fields appear to be discarded.

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

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

The description is a single, front-loaded sentence with no filler. The core action and a key exclusion are both present and useful.

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

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

For a tool with 9 optional parameters, no output schema, and no annotations, the description is too sparse for confident invocation. An agent would not know which parameter to pass or what the label output looks like without additional assumptions.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds little beyond the schema: it does not explicitly identify 'host' as the relevant parameter or clarify that the other eight 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 specific action, 'split a hostname into labels', and names the resource and result. The qualifier 'without WHOIS or ownership data' helps set expectations, though it does not explicitly differentiate from sibling shape-checking 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 implies the tool is for extracting domain labels rather than ownership data, but it does not state when to prefer this tool over siblings like github-repo-shape or normalize-url. The usage context is mostly 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 transparency burden. It usefully discloses that the tool uses HEAD and returns status only, but it omits redirect handling, timeout/error behavior, and whether any parameters other than the URL are actually honored.

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, front-loaded with the verb and target, with zero filler. Every word earns its place.

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

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

For a tool with nine optional parameters, no output schema, and no annotations, a single sentence is insufficient. It leaves the return format, the relevant parameter, and the relationship to sibling URL/status tools 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?

Schema coverage is 100%, so the baseline is 3, but the description gives no mapping to the nine optional parameters. The `url` schema description says 'HTTPS URL to normalize or cite', which conflicts with the stated HEAD-status purpose and leaves the agent unsure which field 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 description names a concrete HTTP method (HEAD), a target class ('public URL'), and the exact output ('status only'). This distinguishes it from content-fetching tools like web-fetch and URL-normalizing tools like normalize-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 obvious trigger — use when you need only the HTTP status of a public URL — but it never states when not to use it or points to siblings such as web-fetch or browser-url-ok. With 28 sibling tools, the lack of explicit routing leaves some overlap unresolved.

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 and does disclose one behavior: the path is discarded. It does not state whether the operation is read-only, what the return value is, or what happens to the many other accepted parameters, so transparency is partial.

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

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

Two short sentences with no filler, and the core action is front-loaded. The second sentence is cryptic enough to cost it 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?

With nine optional parameters, no output schema, and no annotations, the description leaves the agent uncertain which parameter to populate and what result to expect. It does not explain how figma-url-shape fits among sibling shape/URL 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 description coverage is 100%, so every parameter is already documented. The description adds no new parameter-level meaning beyond echoing that the path is discarded, which keeps this 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 identifies a specific verb and resource ('Parse a Figma file URL') and adds one behavioral detail ('Path discarded'), so it is not a tautology. It does not, however, describe the output or how this differs from sibling URL tools like normalize-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 Figma qualifier implies the tool is for Figma URLs, giving some context on when to use it. It never names alternatives or exclusion conditions, so an agent choosing among normalize-url, browser-url-ok, and figma-url-shape gets no explicit routing help.

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

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

With no annotations, the description carries the behavioral disclosure burden. It does disclose a key behavior, 'No disk access,' which signals a non-filesystem, purely syntactic check. However, it does not describe return values, error behavior, which parameters are accepted, or whether other side effects exist.

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

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

Two short sentences, front-loaded with the purpose and followed by the key limitation. There is no filler; each sentence earns its place. The brevity is only acceptable if the schema and annotations supply the remaining context, which they only partially do.

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 required fields, no output schema, and no annotations, yet the description only explains a path-shape check. It does not say what the tool returns, how to choose among the many parameters, or what 'safe' means. Schema property descriptions help, but the overall call contract remains incomplete.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no parameter-level detail, but every parameter already has a one-line schema description, including 'File path to check' for the path parameter. The description's path focus maps reasonably to that parameter, so no additional compensation is 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 states a specific verb and resource: 'Check whether a path looks safe' and adds the important scoping side-effect 'No disk access.' It is distinguishable from URL/disk-access siblings, though 'safe' is not defined and the input schema exposes nine unrelated parameters, making the description narrower than the apparent parameter surface.

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

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

No explicit when-to-use or when-not-to-use guidance is provided, and no alternative tools are named. 'No disk access' implies it is for shape-only checks, but the agent is not told when to prefer this over normalize-url, browser-url-ok, or filesystem tools, nor what conditions make it inappropriate.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not mention that this likely makes an external Open-Meteo network call, whether inputs are discarded, whether there are side effects, failure modes, or what the returned coordinates look like. The one-sentence description adds 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 a single clear sentence with no redundant wording, and the key idea is front-loaded. It is concise, though it achieves conciseness at the cost of important detail.

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

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

For a tool with 9 optional parameters, no required fields, no output schema, and no annotations, a single-sentence description is inadequate. An agent cannot tell which parameter to pass, what the output will be, or whether all parameters are just accepted for validation. Significantly more context is needed.

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 even though the description itself adds no parameter-level guidance. However, the description does not clarify which of the 9 optional parameters identifies the 'place', and none of the schema parameter descriptions mention latitude or longitude, so the description fails to bridge the schema-to-purpose gap.

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

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

The description states that the tool returns latitude and longitude for a place via Open-Meteo, which is a specific enough function to distinguish it from weather forecasting or timezone tools. However, it does not clarify how the 9 heterogeneous input parameters relate to 'a place', and the schema contains no obvious place parameter, making the core purpose somewhat 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?

No guidance is given about when to use this tool versus alternatives, when not to use it, or which input parameter should be provided. The description merely names the provider, not the 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 provided, the description carries the full burden, but it only states the core parsing behavior. It does not disclose behavior for malformed or non-GitHub URLs, output format, or the fact that many other accepted 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. Every word contributes to stating what the tool does.

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 many closely related sibling tools, yet the description is only one line. It does not explain return structure, error handling, or how the unrelated parameters relate to the GitHub-URL parsing 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?

The input schema already covers all parameters at 100%, so the baseline is 3. The description adds meaningful semantics by clarifying that the `url` parameter should be a GitHub URL and that the relevant outputs are owner and repo, which the schema alone does not specify.

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 ('Parse') and resource ('a GitHub URL') and states the intended outcome ('owner and repo'). It is clear and distinguishes the tool from sibling shape tools by naming GitHub, though it does not explicitly name 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?

The usage context is implied: use the tool when you need owner and repo extracted from a GitHub URL. However, it provides no explicit guidance about when to prefer this tool over sibling shape-checkers or what inputs are out of scope.

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 reveal one trait—'Titles discarded'—but it does not explain whether the tool performs network access, what the return value looks like, whether parameters are truly ignored, or any error behavior. This is minimal 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 two short sentences with no filler. The main action is front-loaded, and the 'Titles discarded' note is a useful clarification. It is concise, though slightly terse.

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 that there are 9 optional parameters, no annotations, and no output schema, the description is too thin. It does not state the return type, whether any parameter is actually used for the HN count, or why so many unrelated parameters are accepted. An agent cannot confidently predict the tool's full behavior or output.

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

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

The schema descriptions cover all 9 parameters, so the baseline is 3. The tool description adds essentially no parameter-level meaning; 'Titles discarded' echoes the feed parameter description but does not enrich understanding of the other eight parameters. The schema itself carries the semantic load.

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

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

The description names a specific verb and resource: count current Hacker News front-page stories. 'Titles discarded' further clarifies that the result is a count, not a list of story content. It is clear enough, though it does not explicitly distinguish itself from sibling tools like web-fetch or fetch-status.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention any sibling tool, prerequisite, or context. An agent is left to infer that this is specifically for Hacker News front-page story counts.

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 burden of behavioral disclosure. It does not state what the tool returns, whether it validates names, or that the input parameters appear to be irrelevant/discarded. The schema hints that several fields are 'discarded after' use, but the description itself is nearly behavior-free.

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 eight-word sentence with no filler, front-loaded and easy to parse. It is concise at the expense of completeness, but for the conciseness-and-structure dimension it is well-formed.

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, the description is far too thin. It does not explain the return format, how the parameters relate to the tool, or when to prefer this over sibling tools. It is minimally viable but leaves major 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 description coverage is 100%, and many parameters explicitly say 'discarded after...', so the schema carries the parameter semantics. However, none of the nine parameters relate to IANA timezone selection, and the description gives no mapping between its purpose and these parameters. Baseline 3 is appropriate; the description adds no parameter value 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 identifies the subject ('IANA timezone names') and intended use ('for clock calls'), but it omits a verb such as 'returns' or 'lists' and reads more like a label than an operational definition. It does not distinguish the tool from sibling tools like timezone or utc-time, which are also clock-related.

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 cue is 'for clock calls', which gives context but no condition, alternative, or exclusion. With many sibling tools such as timezone, utc-time, and web-fetch, an agent cannot determine when to call iana-zones instead of another tool.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It reveals that the tool performs a public network fetch and returns only counts, implying read-only behavior. However, it does not mention failure behavior, how inputs are consumed or ignored, redirect handling, or whether a specific user-agent is used.

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 words. It is efficient and readable, though slightly undersized given the complexity of the nine-parameter schema.

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

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

With no output schema or annotations, the description must be self-sufficient. It does not define what 'group counts' means, does not explain which parameter controls the fetch, and does not address error cases. The mismatched schema descriptions worsen the gap, making this too incomplete for reliable invocation.

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

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

The schema has 100% description coverage, but none of the parameter descriptions mention robots.txt, and the tool description does not identify which parameter to pass. 'host' and 'url' are plausible, but several parameters are explicitly described as discarded, creating ambiguity about how the target robots.txt is selected.

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 ('Fetch'), a specific resource ('a public robots.txt'), and a precise output ('group counts only'). It is not a tautology and conveys the tool's core scope, though it does not explicitly differentiate from sibling tools like web-fetch or fetch-status.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no alternative tools are named. The word 'only' implies this is for cases where group counts suffice rather than full content, but the agent is left to infer that rather than being told.

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 state that the key is discarded, which is useful privacy-relevant context, but it does not explain what the tool returns, whether it performs network access, or any other side effects. This is too sparse for a check-style tool with no annotation support.

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 no filler. The primary purpose is front-loaded and the behavioral note follows immediately. It earns its place with minimal words.

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

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

Given a seven-property input schema, no annotations, and no output schema, this description is severely incomplete. It never explains which field contains the Jira key, what constitutes a valid shape, or what the result of the check will be, leaving the agent without enough context to call the tool correctly.

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

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

The schema has high per-property description coverage, but the tool description does not map the 'Jira key' to any of the seven schema properties; none of them is labeled as a key. The description instead adds confusion by referring to a 'key' that does not exist in the input schema, so an agent cannot confidently determine which parameter 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 description states a clear verb and resource: 'Check a Jira issue key shape.' This distinguishes it from sibling shape tools like domain-shape or github-repo-shape by naming the Jira key domain. However, the schema does not actually expose a 'key' property, which slightly undermines clarity.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor does it mention exclusions or conditions. It implies use for validating Jira key shape, but that is left entirely to inference in a tool landscape with many similar shape-checking siblings.

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

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

The only behavioral disclosure is 'Body discarded', which is useful for a status-check tool. With no annotations, the definition does not disclose whether the request follows redirects, what statuses are possible, how multiple parameters are handled, or whether any network/auth side effects occur. That is minimal 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?

The description is two short sentences with no filler; the main purpose is front-loaded and 'Body discarded' is a meaningful addition. It could be expanded with more context, but for what is present it is well-structured.

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

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

For a nine-parameter tool with no annotations and no output schema, a one-line description leaves too much unspecified: parameter selection, sibling differentiation, return status semantics, and behavior under multiple inputs. The 'Body discarded' hint is the only extra context beyond the schema.

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

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

The input schema already documents all nine parameters, so the description is not required to repeat their meanings, meriting the baseline. Still, the description does not map 'public library docs URL' to any specific parameter, and the schema's `url` description ('HTTPS URL to normalize or cite') does not clearly align with the documented purpose. This creates slight ambiguity, but the schema carries the semantic load.

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

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

The description names a concrete result ('HTTP status') and a specific target ('public library docs URL'), and it adds the useful constraint that the response body is discarded. However, it only describes one mode of a schema that accepts city, feed, JSON, path, query, and other fields, so an agent cannot tell the tool's full scope. This makes the stated purpose clear but incomplete and potentially misleading relative to the 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 sentence says when to prefer this tool over siblings like fetch-status, normalize-url, or validate-json, or when not to use it. The only implied context is 'public library docs URL', which does not cover the nine optional parameters.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It adds one behavioral trait ('Values discarded') but does not state whether keys are counted recursively or top-level only, what the return value looks like, or how invalid JSON is handled.

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

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

Two short, front-loaded sentences with no filler. The first sentence states the core operation and the second adds a relevant behavioral detail.

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

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

With 9 optional parameters, no output schema, and no annotations, the description is too thin for an agent to invoke correctly. It omits which parameter carries the JSON object, whether key counting is recursive, and what result format to expect.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds no parameter meaning, and the schema descriptions themselves are partly inconsistent with the stated purpose: only 'json' relates to JSON, while ref, city, feed, and host appear unrelated. Still, the presence of full schema descriptions keeps this 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 states a specific verb and resource: 'Count keys in a JSON object.' The phrase 'Values discarded' clarifies that value content is irrelevant, which distinguishes the operation from validation or retrieval tools. However, it never connects the operation to any schema parameter, so an agent still has to guess that 'json' is the relevant input.

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

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

There is no guidance on when to prefer this tool over siblings such as validate-json or search-query-len, and no exclusions or prerequisites are stated. The only implied usage is the operation itself, which is not enough for robust tool selection.

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

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

The description adds a meaningful behavioral detail: query and fragment are dropped, and the operation is an obvious pure transformation. However, with no annotations, it does not fully carry the burden since it omits output format, invalid URL handling, and the fact that many schema parameters are unrelated to the stated 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?

Two focused sentences, each earning its place: the first defines the output, the second defines an exclusion. It is front-loaded and free of 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?

For the primary url use case the definition is adequate: the agent can infer the intended parameter and expected output. However, with 9 optional parameters and no output schema, a short note that other fields are ignored would make it much more complete and remove ambiguity around feed, host, and path.

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?

Input schema coverage is 100%, so the baseline is 3. The description reinforces that the url parameter is central and that query/fragment are discarded, but it does not clarify the role of the many other optional parameters or that only url should normally be supplied.

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

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

The description states a specific operation: normalize a URL and return origin, host, and path. It also explicitly scopes the behavior by saying query and fragment are dropped, making it easy to distinguish from sibling URL tools like browser-url-ok 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?

It implies the tool should be used when an agent needs the origin, host, or path portion of a URL, and the query/fragment caveat warns against using it when those parts are needed. However, it does not name alternatives or provide explicit when-not-to-use 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 carries the behavioral burden. It discloses one meaningful behavior, that no browser is launched, but it does not say whether an actual network request is made, what the return value is, or whether the URL must be reachable versus merely well-formed.

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

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

Two short sentences, with the primary action first and the key differentiator second. 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 tool with nine optional parameters and no output schema, the description is too thin. It does not define what 'can be opened' means, does not state the returned value (boolean/status/error), and does not explain how the many unrelated-looking parameters relate to the check.

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 covers all nine parameters with descriptions, so the baseline is 3 and the description does not need to repeat them. It adds no extra parameter meaning, but none is required because coverage is 100%.

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 operation ('Check whether a URL can be opened') on a specific resource (a URL). The added sentence 'No browser is launched.' immediately distinguishes it from browser-oriented siblings like browser-url-ok, so the core purpose is unambiguous.

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

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

No explicit when-to-use or when-not-to-use guidance is given. The description does not name an alternative or state the condition for choosing this tool over browser-url-ok or fetch-status; 'No browser is launched' implies a lightweight check but leaves the usage decision to inference.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does say 'Query discarded', which is useful, but it never explains what is returned, how characters are counted, or what happens when the other schema parameters are supplied. For a tool with a large and seemingly unrelated schema, this is insufficient.

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 and front-loads the core action. It contains no filler, though the extreme brevity is a tradeoff against completeness.

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

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

This tool has nine parameters, no output schema, and no annotations, but the description only acknowledges the query parameter and gives no return semantics. The schema helps with parameter meanings, but the overall definition is not complete enough for an agent to confidently 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%, and each parameter has a written purpose in the schema. The description adds little beyond what is already stated for the query parameter, so the schema is doing the heavy lifting and a baseline of 3 is appropriate.

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

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

The description states a specific operation ('Count characters in a search query') and notes that the query is discarded, which gives the agent a basic idea of purpose. However, the input schema exposes nine unrelated parameters (ref, url, city, feed, json, path, zone), and the description does not explain how they relate to the stated purpose, leaving real ambiguity.

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

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

There is no guidance about when to use this tool versus siblings like validate-json, normalize-url, or file-path-ok. The phrase 'search query' weakly implies a use case, but no conditions, exclusions, or alternatives are mentioned.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure, but it reveals nothing about side effects, network access, output format, or whether any of the parameters affect execution. The only behavioral hints appear in the schema's parameter notes, not in the tool description itself.

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

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

The single sentence is brief and front-loaded, but it is under-specified rather than appropriately concise for a tool with seven parameters and no output schema. Brevity is achieved by omitting operation, usage, and return behavior, which reduces the description's practical value.

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 seven-parameter tool with no annotations, no output schema, and a description that never explains how to invoke it or what it returns. An agent cannot reliably determine which parameters to supply or what the catalog operation does with them, making the definition severely incomplete.

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

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

All seven parameters have individual schema descriptions, so schema coverage is high. The tool description adds no parameter-level meaning, but the baseline of 3 applies because the schema already documents each parameter. The description still fails to explain why these diverse parameters fit together, which is a completeness issue rather than a parameter-semantics gap.

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

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

The description states the general subject—a short catalog of common HTTP status codes—and loosely distinguishes this from fetch-style siblings by framing it as a reference catalog. However, it lacks an action verb such as 'returns', 'lists', 'or 'looks up,' and it gives no hint of how the seven input parameters relate to the catalog. The purpose is recognizable but not concretely specified.

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 rather than alternatives like fetch-status, normalize-url, validate-json, or web-fetch. There are no exclusions, prerequisites, or example scenarios. An agent is left to infer both the tool's purpose and its role among the siblings from the name alone.

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

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. 'Prompt discarded' directly tells the agent that its prompt will not affect the returned template, which is the key non-obvious behavior. It does not mention auth, errors, or side effects, but for a pure template-returning tool the most important trait 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?

Two short sentences with the core deliverable front-loaded and no filler. 'Prompt discarded' is a valuable behavioral note that earns its place rather than repeating schema information.

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

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

The core purpose and the discard behavior are stated, and all parameters are optional, so no mandatory input is left unexplained. However, the nine-parameter schema is a strange grab-bag of unrelated fields, and the description does not clarify whether or how to populate them, or what the three steps in the template actually are.

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

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

All nine parameters are fully documented in the input schema, so the description is not required to add per-parameter detail. The description only adds the general 'prompt discarded' hint, which does not meaningfully extend the schema's already explicit 'discarded' notes on individual parameters.

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

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

The description states a specific verb and deliverable: return a three-step thinking template. 'Prompt discarded' further distinguishes it from sibling tools by clarifying it is a static template helper, not a tool that acts on user input. This is enough for an agent to know what the tool does.

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

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

There is no guidance about when to use this tool versus the many sibling tools, no preconditions, and no explicit recommendation to call it with no parameters. 'Prompt discarded' describes behavior but does not help an agent decide when to invoke the tool or what to pass.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It clearly implies a read-only lookup with no side effects, but it does not disclose what the returned time looks like or how invalid timezone names 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 one short sentence with no filler. It front-loads the tool's core behavior and wastes no words.

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

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

For a simple read-only time lookup, the description and schema are enough for basic invocation. However, there is no mention of return format, invalid input behavior, or alternatives among the many sibling tools, leaving the definition minimally complete rather than fully self-sufficient.

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 for its parameters, so the baseline is 3. The description loosely maps to a timezone-naming parameter but adds no new semantic detail beyond what the schema already provides.

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

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

The description clearly states that the tool returns the current time for a named IANA timezone, which makes the core purpose understandable. It does not use an explicit verb and does not explicitly distinguish itself from siblings like utc-time or iana-zones, so it falls just 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 phrase 'named IANA timezone' implies when this tool should be used, but there is no explicit guidance about when not to use it or which sibling tool to prefer. Instructions like utc-time or iana-zones are not mentioned, leaving the alternative selection implicit.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure. It mentions only that the tool returns a current UTC timestamp, but fails to disclose that the many input parameters appear to be accepted and then ignored, or to specify the timestamp format or 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 extremely concise and front-loaded, but it is underspecified for a tool with eight seemingly unrelated input parameters. It is not bloated, yet it is too terse to be fully useful on its own.

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 having a large input schema and no output schema, the description only gives the basic purpose. It does not clarify whether the inputs affect the output, what the return value looks like, or why parameters like 'feed', 'path', and 'json' exist for a UTC timestamp tool.

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

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

The input schema has 100% description coverage for all 8 parameters, with each parameter already described as discarded or side-effect-free. The description adds no parameter-related meaning, so it meets the baseline but does not 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 clearly states the tool returns the current UTC timestamp, identifying both the resource and the time zone. However, it does not explicitly use a verb and does nothing to distinguish itself from the sibling tool 'timezone'.

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

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

No usage guidance is provided. The description does not explain when to prefer this tool over 'timezone' or any other sibling, nor does it state any prerequisites or exclusions.

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

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

Without annotations, the description must carry the burden of behavioral disclosure. It does reveal a meaningful trait – 'The body is discarded' – which indicates no retention or side effects. However, it does not state what the tool returns (e.g., a boolean or error), how it handles invalid JSON, or whether it makes network calls, so the transparency is partial.

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

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

Two short sentences, with the primary action first and a behavioral note second. No filler or repetition, every sentence carries information.

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

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

Despite concise phrasing, the description is under-specified given the tool's 8-parameter schema. It fails to explain why parameters like city, feed, and host exist or how they relate to JSON validation, leaving an agent uncertain about which fields are required. There is no output schema and no indication of return types, so the agent cannot confidently 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 input schema has descriptions for all eight properties, so coverage is 100% and the baseline is 3. The description adds no parameter-specific meaning beyond the schema; the phrase 'a body' maps loosely to the 'json' parameter but ignores the other parameters that are present. Thus it neither helps nor hurts 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?

States a specific verb and resource ('Check whether a body is valid JSON') and is unambiguous among the sibling tools, none of which address JSON validation. The added 'The body is discarded' note sharpens the scope, so an agent knows this is a stateless validation check. No misleading or tautological phrasing.

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 choose validate-json over sibling validation tools (e.g., file-path-ok, wiki-title-ok, domain-shape). The description never mentions alternatives, prerequisites, or a decision context. An agent is left to infer when JSON validation 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 provided, the description carries the full behavioral disclosure burden, but it only states the happy path. It does not disclose that non-city parameters appear to be discarded, that an external Open-Meteo call is made, what units are returned, or what happens when no city is provided; there is also no output schema to fill these gaps.

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

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

The description is a single sentence with no filler and is front-loaded with the primary purpose. However, for a tool with nine unrelated optional parameters and no output schema, it is under-specified rather than 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?

The description is not enough to invoke the tool reliably: it does not state which parameter should be supplied, what the response looks like, or how to treat the many irrelevant schema parameters. With no annotations, no output schema, and a large sibling list, the available context is insufficient.

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 tool description. The description reinforces that 'city' is the meaningful parameter, but it does not clarify that the other eight optional parameters are irrelevant or ignored, which is a meaningful gap for such an overloaded 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 names the action (current temperature), the resource (a city), and the data source (Open-Meteo), making the core function clear. It is not phrased as an imperative verb and does not explicitly differentiate from sibling 'hint' tools, but it is specific enough to identify a weather lookup.

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 can infer to call this tool when a current temperature for a city is needed. However, there is no explicit when-to-use or when-not-to-use guidance, and the sibling list includes related tools like geo-hint that could be confused with it.

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

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

With no annotations, the description must carry the behavioral burden; it does disclose the important trait that the response body is discarded. It does not mention redirect handling, failure behavior, or JS execution, so transparency is partial rather than complete.

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 are used: the first leads with the tool's output, and the second adds a crucial caveat. 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?

The tool has no annotations, no output schema, nine optional parameters, and many sibling tools, yet the description does not explain which parameter to use, what the response structure is, or how failures and redirects are handled. The terse description is understandable as a one-liner but insufficient as a complete tool contract.

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 and the description does not need to restate parameter meanings. The description adds no further parameter guidance, such as confirming that the url property is the one to populate, and the schema's varied discard-style fields are left for the agent to reconcile.

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 that the tool returns HTTP status and content type for a public URL and that it discards the body, so the core operation is identifiable. It does not explicitly differentiate from closely related sibling URL tools such as fetch-status or browser-url-ok, 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 'public URL' qualifier and 'Body discarded' imply when it is appropriate: checking a URL's reachability and content type without needing content. However, it provides no explicit when-not-to-use guidance or alternatives, despite several sibling tools performing overlapping URL checks.

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

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

No annotations are present, so the description carries the full burden. It does disclose a meaningful lifecycle trait ('Title discarded after the call') and implies a read-only existence check. However, it omits the output format, whether a network request is made, or failure behavior, leaving transparency only partial.

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

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

Two short sentences, no filler, and the core purpose is front-loaded. The second sentence adds a useful lifecycle detail without bloat. This is as concise as a description can be.

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

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

With seven parameters, no annotations, and no output schema, the tool is deeply under-specified. The description does not say which parameter holds the Wikipedia title, what the tool returns, or any constraints. An agent cannot reliably invoke the tool based on this definition alone.

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

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

The schema fully describes seven parameters, but none is a Wikipedia title—they are ref, url, city, feed, host, json, and path. The description adds no mapping between 'title' and any property, and the only mention of 'title' is the discard note. High schema coverage cannot compensate for this critical mismatch, which prevents correct invocation.

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

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

The description states a specific verb and resource: 'Check whether a Wikipedia title exists.' This is unambiguous and distinguishes this tool from sibling shape-checkers by the unique subject matter. The absence of a title parameter in the schema slightly clouds practical use, but the stated purpose itself is crystal clear.

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

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

No guidance is provided for when to use this tool over the many sibling checkers (e.g., domain-shape, github-repo-shape). The 'Title discarded after the call' note is a behavioral detail, not a usage guideline. An agent is left entirely to infer context from the tool name and description.

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