ISO country CY

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

Annotations already cover the read-only safety profile, so the bar is lower. The description adds value by disclosing what it returns and the privacy-relevant trait that 'Task text discarded.' It does not, however, explain whether network calls are made, whether results are cached, or how 'remote MCP hops' are delivered.

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?

Three dense sentences with the main purpose and output list front-loaded; no filler. The final 'Task text discarded.' sentence earns its place as a behavioral caveat, though the unexplained 'Monid' reference costs the fifth point.

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

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

With nine parameters and no output schema, the description should explain the invocation model, but it never says which input (if any) actually drives the gateway lookup, what Monid is, or how the four returned artifacts are structured. An agent can tell that most inputs are discarded, but not what it should supply to get a result.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters, making 3 the baseline. The description adds only one param-level insight—that task text is discarded—which largely echoes the per-parameter 'discarded' notes already in the schema.

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

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

The description names a specific verb ('Find'), a specific resource ('public pay-per-call tool gateway (Monid)'), and enumerates the return artifacts ('CLI setup, how-it-works, skill file, and remote MCP hops'). This makes it clearly distinct from the check/hint-style sibling tools. However, 'Monid' and 'tool gateway' are unexplained jargon, so the purpose is clear but not fully self-contained.

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 rather than stated: call this when you need Monid's gateway setup artifacts. There is no explicit when-to-use vs when-not-to-use guidance, and no alternative routing to any of the 27 siblings (e.g., 'use web-fetch for raw page content instead').

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

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

No annotations are provided, so the description carries full behavioral disclosure burden. It discloses one trait (no browser launch) but omits what the check actually does, whether it makes a network request, what the return value looks like, how redirects/errors are handled, and why most of the schema parameters are ignored. The description is too thin to let an agent anticipate behavior.

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

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

The description is only two sentences, front-loads the main action, and contains no filler. It earns a 4 for efficient structure, but not a 5 because the extreme brevity leaves out important context for a tool with a large, confusing input schema.

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

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

With no output schema and no annotations, the description must provide more context than it does. It does not say what 'ok' means, what result is returned, or which of the many parameters are relevant. An agent could not confidently decide whether to pass url, host, path, or any other property, making the tool description insufficient 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?

Every property in the input schema has a description, so schema_description_coverage is high and the baseline is 3. The tool description adds no parameter-level meaning, and the url property description ('HTTPS URL to normalize or cite') is somewhat misaligned with the stated checking purpose, though not a direct contradiction.

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 on a specific object: 'Check whether a URL can be opened.' The second sentence, 'No browser is launched,' helps distinguish it from sibling tools like playwright-url-ok. It falls short of 5 because 'can be opened' is not defined (HTTP status? TCP reachability?) and it does not differentiate from related tools like fetch-status or web-fetch.

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

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

The description only implies usage: because no browser is launched, it is presumably for lightweight URL checks. There is no explicit 'when to use this vs. alternatives' guidance, no prerequisites, and no exclusion of cases that require a real browser. This is at the 'implied usage' level, not clearly actionable.

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 behavioral burden. It does disclose one meaningful behavior: the expression is discarded after evaluation, implying no persistence. However, it does not describe the result format, error behavior, or whether any side effects occur beyond computation, so the disclosure is only partial.

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

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

The description is two short sentences with no wasted words. It front-loads the core operation ('Evaluate a+b style arithmetic') and adds the important discard behavior as a brief second sentence.

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 minimally viable for a simple evaluation tool, but it does not explicitly state the return value, error behavior, or which parameter to populate. The schema compensates for parameter details, yet without annotations or an output schema, the description alone leaves some 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 input schema has descriptions for all parameters, including the key 'expression' parameter with 'a+b expression to evaluate; result shown, expression discarded'. The description adds no parameter meaning beyond what the schema already provides, so the schema does the heavy lifting.

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

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

The description clearly states the tool evaluates arithmetic expressions in an a+b style, which identifies the verb and resource. It is distinguishable from the sibling tools by function, though it does not explicitly name any sibling or contrast itself.

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 other tools, no prerequisites, and no mention of alternatives. The description only implies that it should be used for arithmetic evaluation, leaving selection decisions 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?

The description mentions that page content is not stored, but does not disclose whether the tool performs a network request, how it handles multiple URL-like parameters, or what side effects may occur. With no annotations provided, these behavioral details are largely absent.

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

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

The description is very concise—two short sentences—and gets directly to the point without extraneous 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?

There is no output schema, no example, no error behavior, and no explanation of how the optional parameters interact. The description is too sparse to fully guide an agent in correctly invoking 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?

The schema descriptions are individually clear, but the tool description only relates to 'url'. The other optional parameters (ref, city, feed, host, json, path, zone, query) have no explained connection to the stated purpose, leaving parameter usage ambiguous.

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 host, scheme, and HTTP status for a URL, and explicitly notes that page content is not stored. This distinguishes it from content-fetching tools, though the presence of many unrelated optional parameters slightly muddies the intended scope.

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

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

No guidance is given about when to use this tool versus sibling tools like fetch-status or normalize-url. The only contextual note is that page content is not stored, but there is no explicit when-to-use or when-not-to-use instruction.

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

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

With no annotations, the description carries the full behavioral burden. It does add a useful privacy disclosure ('No identifiers are retained') and the schema reinforces discard behavior for individual parameters. Still, it does not explicitly state whether the tool is read-only, whether it makes external calls, or what its output structure is.

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 front-loaded and efficient: one purpose sentence and one privacy sentence with no filler. It is appropriately short, though the brevity contributes to the lack of operational 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?

This tool has seven heterogeneous parameters, no output schema, and no annotations, yet the description does not explain how the parameters combine, what classification output to expect, or how the result should be interpreted. An agent would likely need external knowledge 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 already describes each of the seven parameters meaningfully, including discard behavior, so schema coverage is high. The description adds no parameter-level meaning beyond the privacy guarantee, so it does not improve on 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 states that the tool classifies or shows classification of a request, so there is a verb and resource. However, it never says what classifications are produced, what input shape is expected, or how this differs from the many sibling validators and 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?

There is no guidance about when to use this tool instead of alternatives like validate-json, domain-shape, file-path-ok, or normalize-url. The phrase 'Show how this request is classified' implies a generic classification use case, but it does not state conditions, exclusions, or prerequisites.

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

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

With no annotations, the description carries the full burden. It only says WHOIS/ownership data is absent; it doesn't disclose invalid-hostname behavior, side effects, discarded inputs, or return shape. Schema hints that some fields are 'discarded' are not in the description and cannot compensate.

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

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

The description is a single tight sentence, front-loaded with the action and the key exclusion, with no filler. It is concise but at the cost of completeness, so it earns a 4 rather than a 5.

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

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

For an 8-parameter tool with no annotations and no output schema, one sentence is insufficient: required vs optional fields, output format, failure behavior, and positioning among sibling tools are all missing. The 'host' parameter in the schema is the only clue to how to invoke it.

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

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

The schema documents all properties, so the baseline is 3, but the description adds no parameter guidance and the schema mixes unrelated fields (city, feed, json, path, and a root-level 'Name of a file to delete' description) that don't fit a hostname-splitting tool. An agent has no explicit pointer that 'host' is the relevant input.

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 ('Split a hostname into labels') and a clear boundary ('without WHOIS or ownership data'), which distinguishes it from enrichment/ownership tools. It doesn't define the output shape or mention any siblings, but the core purpose is unambiguous.

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

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

Usage context is implied: this is for syntactic hostname splitting, not for WHOIS or ownership lookup. It gives no explicit when-to-use/when-not-to-use comparison with sibling tools such as normalize-url or fetch-status, so the agent must infer the boundary.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose the HTTP method, the public-URL scope, and that only status is returned, which is meaningful. However, it omits caveats such as redirects, timeouts, failure behavior, and the fact that many accepted schema fields appear to be ignored.

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

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

The description is one short, front-loaded sentence with no filler. It quickly communicates method, target, and output shape, which is an efficient use of the available space.

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

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

For a tool with 9 optional parameters, no annotations, no output schema, and many closely related siblings, a single sentence is not sufficient. An agent cannot tell which parameter to pass, what the status result looks like, or how this tool differs from the other URL-status and fetching 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 descriptions cover 100% of the 9 parameters, so the baseline is 3. The tool description adds no guidance about which parameter drives the HEAD request, and the schema's url description ('HTTPS URL to normalize or cite') conflicts with the stated purpose, leaving the agent to guess which field is actually relevant.

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

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

The description names a concrete operation: issue an HTTP HEAD request against a public URL and return only the status. This is specific enough to distinguish it from a full-fetch tool like web-fetch, though it does not explicitly compare itself to sibling URL-status tools. The unusually broad input schema adds ambiguity, but the description itself states a clear verb, resource, and result.

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 fetch-status versus siblings such as browser-url-ok, playwright-url-ok, web-fetch, or status-catalog. An agent is left to infer whether fetch-status is preferred for HEAD-style checks, public URLs only, or cases where response bodies are unnecessary.

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 must disclose behavior itself. It only mentions 'Path discarded' and omits what the parse result looks like, whether any network or filesystem access occurs, and how invalid URLs 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 two short sentences with no filler. The core action is front-loaded, and the 'Path discarded' note adds behavioral information without redundancy.

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

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

With nine optional parameters, no annotations, and no output schema, the description is incomplete for reliable invocation. It does not state the expected return value, the required parameter, or how Figma URL shape validity is determined.

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 does not clarify which parameter should hold the Figma URL, and the 'url' parameter is described generically as 'HTTPS URL to normalize or cite,' though an agent can reasonably infer `url` is the intended input.

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 a Figma file URL.' This distinguishes it from sibling shape/URL tools, though it does not clarify what the parsed 'shape' is or what the tool returns.

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

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

The resource type ('Figma file URL') implies when this tool should be used, but the description gives no explicit guidance on when to prefer it over normalize-url, browser-url-ok, or other sibling URL tools. No exclusions or alternative routing are provided.

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

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

The description discloses that no disk access occurs, which is useful behavioral information, especially given no annotations are provided. However, it does not explain return values, error behavior, or whether the check is purely syntactic or heuristic, leaving important behavioral aspects unspecified.

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

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

The description is very brief and avoids unnecessary words; both sentences contribute meaning. The structure is not elaborate, but for such a short description it is appropriately sized and front-loaded with the core action.

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 incomplete in context: no output schema exists, no return type is mentioned, and the tool's relationship to its nine parameters is unexplained. The large set of irrelevant parameters makes the tool contextually confusing rather than self-contained.

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 every parameter has a description, most are unrelated to the tool's stated purpose. The schema includes ref, url, city, feed, host, json, zone, and query, while only 'path' aligns with 'file-path-ok.' This mismatch is misleading and severely undermines parameter semantics.

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

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

The description states the tool checks whether a path 'looks safe' and explicitly says 'No disk access,' giving a basic sense of purpose. However, 'looks safe' is vague and does not specify what safety criteria are used (e.g., traversal, absolute path, syntax), leaving the exact purpose ambiguous.

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

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

No guidance is given on when to use this tool versus alternatives. It does not mention scenarios, prerequisites, or contrast with sibling tools like browser-url-ok or domain-shape, so an agent has no basis for selecting it over other validators.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the core function but fails to disclose that many parameters are 'discarded', that the city parameter appears to be the relevant input, or any error/edge-case 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, efficient sentence with no wasted words. However, the brevity comes at the expense of essential routing information, making it under-specified rather than meaningfully 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?

In a suite containing many shape-check and hint tools, this description gives an agent almost nothing to go on: no input mapping, no expected output format, no constraints, and no alternative guidance. An agent 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?

The schema provides descriptions for each parameter, so the baseline should be around 3, but the tool description does not help map 'a place' to a specific parameter. The schema's 'discarded after the shape check' style notes actually add confusion because they don't align with a tool that returns coordinates.

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 tool returns latitude and longitude for a place via Open-Meteo, which names a clear output and data source. However, it does not specify how 'a place' is identified among the many input parameters, nor does it differentiate this tool from siblings like weather-hint or timezone.

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

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

No guidance is given on when to use this tool versus alternatives. The description does not mention sibling tools or provide conditions under which geo-hint should be selected over weather-hint, timezone, or other location-related 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 of behavioral disclosure. It only says 'Parse,' which implies a read-only operation, but it does not describe error behavior for non-GitHub URLs, return format, or the fact that most schema 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 the tool's purpose.

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

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

For a tool with nine schema parameters, no annotations, and no output schema, this description is too thin. It leaves unclear which parameters are actually used, what the returned owner/repo object looks like, and how invalid or non-GitHub URLs are handled.

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

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

Schema coverage is 100%, so the baseline is 3; every parameter already has a description. The tool description adds GitHub-specific intent and output fields, but it never explicitly maps the GitHub URL to the 'url' parameter or explains the presence of the many unrelated-looking parameters.

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

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

The description uses a specific verb ('Parse') and a specific resource ('owner and repo from a GitHub URL'), so the core purpose is immediately clear. It doesn't explicitly contrast with sibling tools like normalize-url or jira-key-shape, but the GitHub-specific resource strongly disambiguates it.

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 about when to use this tool versus alternatives, nor does it mention when not to use it. An agent must infer from the tool name and sibling list that this is for GitHub repo owner/repo extraction.

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 discloses that the count is 'current' and that 'titles discarded' — useful behavioral signals. Still, it does not mention output format, whether a network fetch is performed, or any side effects, leaving some behavior 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 extremely concise and front-loaded. It names the action and resource in the first sentence and adds a useful behavioral qualifier in the second. There is no filler or redundant restatement of the tool name.

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 with zero required parameters, the description is mostly sufficient: an agent can likely call it with no arguments and expect a numeric count. However, the nine optional parameters are unrelated to the stated HN-count purpose, and the absence of an output schema leaves some uncertainty about the exact return shape.

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

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

Schema description coverage is 100%, so the baseline is 3. Each of the nine parameters has a description, and most explicitly note that the value is 'discarded after' some check. The main description adds no tool-specific parameter guidance and does not map any parameter to the HN count behavior.

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.' This clearly defines the tool's core purpose. 'Titles discarded' further clarifies that the output is a count, not story titles, which distinguishes the tool from content-fetching siblings.

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

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

The description implies the tool should be used when a count of current HN front-page stories is needed and suggests it should not be used if titles are required. However, it does not name alternative tools or explicitly state when to prefer another sibling, so the guidance remains 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the tool provides common timezone names, but does not mention that parameters are discarded, what the return value looks like, or any side effects. The schema reveals that inputs are ignored, but the description itself offers no such 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 short fragment, which is concise, but it lacks verb structure and provides minimal content relative to the tool's 9-parameter schema. It is under-specified rather than efficiently concise, as the few words do not explain the tool's behavior or the purpose of its inputs.

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 and no output schema, the description should clarify what the tool returns and why the inputs exist, especially since they appear unrelated to the stated purpose. The description gives only a high-level hint and leaves the agent without enough context to safely call the tool or interpret its result.

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

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

The input schema gives detailed descriptions for all 9 parameters, including notes that many are discarded. Since schema coverage is high (100%), the baseline is 3. The description adds no extra meaning about the parameters, so it neither improves nor worsens the semantics 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 names a resource (IANA timezone names) and gives a purpose (clock calls), but lacks a verb like 'returns' or 'lists', making it a noun phrase rather than a clear action. It is somewhat distinguishable from sibling tools like 'timezone' or 'utc-time' by focusing on names, but the intended operation is implied rather than stated.

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

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

The phrase 'for clock calls' hints at a context, but there is no explicit guidance on when to choose this tool over siblings such as 'timezone' or 'utc-time'. No alternatives, exclusions, or conditions are given, leaving the agent to infer usage.

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 it fetches a public resource and returns only group counts, which gives some behavioral context. However, there are no annotations, so the description carries the full burden; it does not mention failure behavior, response shape beyond counts, or any network-related caveats.

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 earns its place by communicating the core action and output, though it sacrifices necessary parameter guidance for brevity.

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

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

Given the eight-parameter schema with irrelevant descriptions, no annotations, and no output schema, the one-sentence description is insufficient. An agent cannot determine which parameter to use, what the 'group counts' return structure looks like, or how errors are handled.

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

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

The input schema lists eight parameters, but their descriptions are unrelated to robots.txt (e.g., 'Git ref name', 'JSON text to validate', 'City name for a public weather hint'). The tool description does not explain which parameter identifies the robots.txt URL, making it impossible to invoke the tool confidently from the definition alone.

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

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

The description states a specific verb and resource: 'Fetch a public robots.txt' and the output is 'group counts only.' This clearly conveys what the tool does. However, it does not distinguish itself from sibling tools like web-fetch or fetch-status, which could also retrieve robots.txt content.

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 robots.txt group counts but gives no guidance on when to choose this over alternatives such as web-fetch or fetch-status. No exclusion criteria or alternative tool names are mentioned, leaving the AI agent to infer the appropriate context.

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

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

The sentence 'Key discarded' is a small transparency signal that the tested value is not retained, and the tool name suggests a non-mutating check. With no annotations provided, the description still fails to disclose what happens for valid vs. invalid shapes, return behavior, or any 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 short and front-loaded, but the fragment 'Key discarded.' is cryptic and unexplained. Conciseness is achieved at the expense of useful structure, so it is merely average.

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 seven possible inputs, no required fields, no output schema, and no annotations, this description provides almost no information needed to select or invoke it correctly. The central mapping from description to schema is missing entirely.

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 all seven parameters have schema descriptions, none of them is described as a Jira issue key, and the description does not indicate which parameter should be submitted. A tool named jira-key-shape with no 'key' input leaves an agent unable to construct a correct call.

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

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

The description names a specific resource ('Jira issue key') and a specific verb ('Check'), which makes the basic purpose clear and distinguishes it from sibling shape-checkers. However, the input schema contains no 'key' property, so the clarity is limited to intent rather than invocation.

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

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

There is no guidance about when to use this tool instead of a sibling, nor any exclusions. 'Check a Jira issue key shape' implies a validation use case, but it never explains the conditions under which the tool should be selected.

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 trait: the body is discarded and only the HTTP status matters. However, it omits network details like redirect handling, timeouts, error behavior, and whether the operation is read-only, though read-only is implied by 'HTTP status for a URL.'

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-loads the main behavior, with 'Body discarded' adding a useful second piece of information. There is no filler, though the terseness contributes to a lack of completeness elsewhere.

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

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

For a tool with no output schema and no annotations, the description is too thin. It does not explain the unexpected nine-parameter schema, which parameter(s) an agent should supply, the exact response format, or failure behavior. The mismatch between the description and the input schema is a major completeness gap.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds no parameter guidance and the schema is confusingly mismatched: 'url' is described as 'normalize or cite' rather than status-checking, and the other eight parameters like city, feed, json, and zone are unrelated to the stated purpose. This active confusion lowers the score below 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 clear behavior: retrieve the HTTP status for a public library docs URL and discard the body. This identifies a specific resource and action, and the 'Body discarded' note helps distinguish it from body-returning fetch tools. It does not explicitly differentiate from siblings like fetch-status or browser-url-ok, so it stops short of 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 guidance about when to use this tool versus alternatives such as fetch-status, browser-url-ok, or web-fetch. There are no exclusion conditions or mention of sibling tools to help route an agent's 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?

It discloses that values are discarded, which is a key side effect, and the schema's optional-string parameters hint at a harmless read-only operation. However, since no annotations are provided, it does not fully disclose error behavior, return value, or what happens with zero keys.

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

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

The two-sentence description is extremely concise and front-loaded, with no filler or redundant content.

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, the description should state the return value and input format more explicitly. 'Count keys' implies an integer count, but the description does not explain how to supply the object given the parameter list, leaving some 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 description says values are discarded but does not clarify that the nine listed parameters are simply possible top-level keys and that none are required. The individual parameter descriptions in the schema are misleading (e.g., 'json' says validate) and do not match the count-keys behavior.

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 counts keys in a JSON object and that values are discarded, which establishes the core operation. It is slightly less clear how the object is supplied given the flat parameter list, but the purpose itself is unambiguous.

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

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

No guidance is given about when to prefer this tool over related siblings like validate-json or search-query-len. The description implies counting-key use cases but does not state alternatives or prerequisites.

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

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

With no annotations, the description carries the full disclosure burden. It does disclose the key transformation: the tool returns only origin/host/path and deliberately drops query and fragment. But it does not mention whether this is a purely local parsing operation, how invalid URLs are handled, or other edge cases such as case normalization or trailing slashes, leaving the description only partially transparent.

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 main behavior and immediately communicates the important exclusion of query and fragment. 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?

The input schema contains seven parameters that look unrelated to URL normalization, and there is no output schema. The description does not state that only `url` should be used, whether the other parameters are accepted but ignored, or what a caller should do with them. This ambiguity makes the definition incomplete for an agent navigating the noisy 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?

All seven parameters have schema descriptions, so the baseline is 3. The tool description adds context about URL component extraction but does not clarify that `url` is the primary parameter or how the seemingly unrelated parameters like `json`, `city`, and `feed` relate to the tool. The schema descriptions already carry most of the parameter-level information.

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

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

The description states a specific verb and resource: 'Return origin, host, and path for a URL.' It clearly distinguishes this from fetching or checking tools like web-fetch or browser-url-ok by focusing on component extraction, and it adds the key detail that query and fragment are dropped. However, it does not explicitly name a sibling or compare itself, 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. It never mentions a condition like 'use when you only need URL components' or warns against using it when a full fetch or URL validity check is needed. The agent is left to infer usage 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?

The description discloses that no browser is launched and some parameters are 'discarded', but it does not explain the actual checking mechanism, whether network requests are made, or what failure/success behavior looks like. With no annotations, more transparency is needed.

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 core purpose, with no unnecessary wording. It is slightly too sparse to organize the complex parameter list, but it is efficiently written.

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 and no output schema, the description omits important context such as return type, behavior when no parameters are supplied, error cases, and why unrelated parameters exist. The minimal context is not enough for such a broad 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?

Although the schema has 100% description coverage, many parameter descriptions are inconsistent with the stated purpose (e.g., url is described as 'HTTPS URL to normalize or cite', and city/feed/json/zone/query are only mentioned to be discarded). The top-level description does not clarify which parameters actually matter or how they relate to the URL check.

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 goal: check whether a URL can be opened, and notes that no browser is launched. However, 'can be opened' is somewhat ambiguous (HTTP reachability vs. browser rendering) and no explicit distinction from sibling tools is made.

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

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

No guidance is given on when to use this tool over alternatives like browser-url-ok, fetch-status, or web-fetch. The only usage hint is the negative constraint that no browser is launched, which is not enough.

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 states that the query is discarded after the length check, which implies no persistence side effect and adds some transparency. However, it does not clarify how the other eight input fields are handled or whether any external calls occur, and no annotations are provided to fill this gap.

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

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

The description is short and to the point with no filler words. It could include more detail, but it is not verbose or redundant.

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 a complex schema with nine optional parameters and no output schema, but the description does not tie these together or state the return type (e.g., character count, code points). It also does not explain error behavior or which parameters are ignored, so the operational context is 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?

The 'query' parameter is described as search text that is discarded after the length check, which adds useful meaning. But the other eight parameters have descriptions that appear unrelated to a query-length tool (e.g., IANA timezone, JSON validation), creating confusion about whether they are actually used.

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 counts characters in a search query, which matches the tool name and indicates a specific action. It does not explicitly name which parameter is the query, but the schema includes a 'query' field that aligns with the purpose.

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

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

There is no guidance on when to use this tool versus sibling count/length tools such as memory-key-count or hn-front-count. The description provides no context about appropriate scenarios or alternatives.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that a catalog exists, without mentioning what the tool does with its parameters, whether it is read-only, what output format it returns, or that most parameters appear to be 'discarded.' The schema hints at some behavior, but the description itself is silent.

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

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

The description is a single sentence with no filler, and the resource is front-loaded. However, for a tool with ten parameters and no annotations or output schema, this extreme brevity becomes under-specification rather than appropriate 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?

Given ten parameters, no annotations, and no output schema, the description would need to explain the role of parameters, the return value, and when to use the tool. It does none of this, leaving an agent with a severe information gap and high risk of misuse.

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?

With schema coverage at 100%, the baseline is 3, but the description adds zero meaning about parameters. More importantly, the parameters (ref, city, feed, host, json, path) seem unrelated to a status-code catalog, and the description does not resolve this mismatch. An agent cannot determine which parameters are relevant or how they affect the returned catalog.

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

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

The description names a specific resource ('short catalog of common HTTP status codes') and implies a reference/lookup operation, which is distinguishable from fetching or checking a live status. However, it lacks an explicit verb and does not clarify whether the tool returns the catalog or uses the listed parameters to filter it, so differentiation from siblings like fetch-status is only implicit.

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

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

The description provides no guidance on when to use this tool versus alternatives such as web-fetch, fetch-status, or normalize-url. There is no mention of context, exclusions, or alternative tools, leaving the agent to guess the appropriate invocation scenario.

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 disclosure burden. It does reveal that the prompt is discarded, but it says nothing about whether the eight parameters are ignored, whether the template can vary, or what the output looks like. This is minimal disclosure for a tool with multiple 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 two short sentences with no filler words, making it highly efficient. However, the brevity leaves behavioral and usage questions unanswered, so conciseness comes at the cost of completeness. Still, the wording is well-structured and front-loaded.

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

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

Given the tool's eight parameters and the large sibling set, this description is too sparse. It does not explain what the three-step template actually is, how an agent should use the result, or why this tool exists among similar-looking tools. There is no output schema, so the return value is underspecified.

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 eight parameters are fully described in the input schema, including the fact that each is used only for a shape check and then discarded. The description adds no additional parameter meaning, but the schema already covers this comprehensively, so the baseline 3 applies.

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

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

The description states a clear action ('Return') and a specific resource ('a three-step thinking template'), which is enough to understand the basic purpose. However, it does not distinguish the tool from siblings or clarify what the template contains, and 'Prompt discarded' adds ambiguity about how inputs are used.

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 any of the many sibling tools. No conditions, prerequisites, or alternatives are mentioned. The only contextual hint is 'Prompt discarded,' which does not help an agent decide when this tool is appropriate.

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

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

There are no annotations to carry the safety or side-effect burden, so the description must do that work. It states only the basic current-time behavior and says nothing about whether inputs are ignored, whether the call is safe/read-only, or what the response contains. The schema hints that all provided fields are 'discarded after the shape check,' but the tool description itself does not disclose this 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 wasted words. It is appropriately terse for a simple tool, though the terseness omits the crucial timezone-parameter detail that would make it usable.

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 seven schema properties, no annotations, and no output schema, this description is not nearly complete. It fails to specify which parameter supplies the IANA timezone, how the time is formatted, or what the agent should expect in the response. The agent would have to guess or consult sibling tools to fill the gaps.

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

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

The schema has descriptions for all seven properties, which normally yields a baseline of 3. But the tool description references a 'named IANA timezone' while no input property represents a timezone; the existing properties are all described as discarded or unrelated. The description therefore fails to map its central concept to any parameter and actively obscures how to call the tool correctly.

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

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

The description names a concrete operation—'current time'—and a concrete resource, 'a named IANA timezone.' This distinguishes it from the sibling utc-time, which would be UTC-only, and from iana-zones, which lists zones. However, 'named' implies a timezone parameter that does not exist anywhere in the input schema, so the purpose is clear in intent but not in invocation.

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

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

The description implies the tool should be used when an agent needs the current time in a non-UTC IANA timezone, but it never says this explicitly. It also gives no alternatives or exclusions, such as 'use utc-time for UTC' or 'see iana-zones for valid names.' Usage context is only 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 provided, the description carries the full burden of behavioral disclosure, but it only states the output fact. It does not explain that all nine optional parameters appear irrelevant to the result, what format the timestamp takes, or whether the call has side effects. The schema's per-parameter discard hints are not connected to the tool's actual behavior in the description.

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

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

The description is a single, short, front-loaded sentence with no extraneous content. It is appropriately sized for a simple utility, though it sacrifices useful context about the parameter surface.

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 and no output schema, the one-sentence description is not sufficient for an agent to call the tool confidently. It does not specify the return format or clarify that the parameters are effectively irrelevant, making the definition incomplete despite the simplicity of the core operation.

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 documented in the input schema itself. The tool description adds no additional parameter meaning, which meets the baseline for high schema coverage. It still leaves unclear whether any of these parameters actually influence the returned UTC timestamp.

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

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

The description clearly identifies the tool's output as a 'current UTC timestamp,' which tells an agent what to expect. It lacks an explicit verb and does not differentiate itself from sibling tools like 'timezone,' so it falls short of a top score.

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

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

Usage is implied by the name and the phrase 'Current UTC timestamp': an agent can infer this is for fetching the current time in UTC. However, there is no explicit when-to-use guidance, no mention of alternatives, and no exclusionary context distinguishing it from the 'timezone' sibling.

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

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

With no annotations, the description must carry the behavioral burden; it only says the body is discarded. It does not disclose the return value (e.g., boolean/error details), behavior on invalid JSON, or whether any URL/feed parameters are actually used. This is minimal 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?

Two short sentences with no filler, and the discard behavior is front-loaded. It loses a point because the undefined 'body' makes the wording less precise than it looks.

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 seven optional parameters, no annotations, and no output schema, this description is markedly incomplete. An agent cannot tell which parameter to populate, what result to expect, or whether the extra fields are relevant.

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 independently describes all seven properties, but the description's 'body' has no corresponding property and never maps to the `json` parameter. It also leaves the purpose of the remaining unrelated fields unclear in relation to JSON validation, so the description adds confusion rather than value.

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

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

The description contains a specific verb and resource: 'Check whether a body is valid JSON.' That tells an agent the core purpose. It does not differentiate from sibling shape-check tools like domain-shape or github-repo-shape, and 'body' is not defined, 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?

The purpose implies the tool is for validating JSON, so the context of use is implied. However, it never states when to prefer this over alternatives, what prerequisites exist, or which input form to provide, so guidance is only 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?

Annotations already cover the safety profile (readOnly, non-destructive, idempotent, non-sensitive), so the description's burden is light. It adds that Open-Meteo is used and that the return is a current temperature, but doesn't disclose request/response behavior or caveats. This is minimal but not contradictory.

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 concise sentence with no filler. The main idea is front-loaded and easy to parse, though it could include slightly more operational detail without losing 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 a noisy seven-parameter schema and no output schema, but the description does not specify required parameters, return units, or how to ignore irrelevant inputs. An agent could be confused by the unrelated parameters and lacks enough information to invoke the tool confidently.

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

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

The input schema provides descriptions for all parameters, so the baseline is 3. The description highlights 'city' as relevant, but the schema also lists six unrelated parameters (ref, url, feed, host, json, path) with discard notes; the description does not help the agent understand that only 'city' should be used or that the others are likely irrelevant.

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 function: returns current temperature for a city, and names the source (Open-Meteo). It is unambiguous about the domain, though it doesn't explicitly distinguish it from sibling tools like geo-hint.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't name sibling tools, conditions, or exclusions. The Open-Meteo reference implies an external weather source, but no usage criteria are offered.

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

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

With no annotations, the description carries the full burden. It discloses that only status/content type are returned and the body is discarded, but it omits behavior around redirects, errors, timeouts, and whether any request side effects occur.

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

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

The main description is a concise one-liner, but the tool definition is bloated with nine optional parameters, most of which are irrelevant to the stated purpose. The overall structure lacks focus and includes many unnecessary fields.

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

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

For a tool with nine parameters and no output schema, the description is severely incomplete. It does not explain which parameters are meaningful, what the response format looks like, or how the caller should construct a valid request.

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 parameter descriptions are incoherent for a web-fetch tool: ref, city, feed, json, path, zone, and query appear unrelated to fetching a URL, and even the 'url' description mentions normalization/citation rather than fetching. Schema coverage is 100%, but the descriptions actively mislead.

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 tool returns HTTP status and content type for a public URL and explicitly says the body is discarded. This distinguishes it from full-page fetchers, though it does not use an explicit verb like 'fetch'.

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

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

No guidance is provided about when to use this tool instead of siblings like fetch-status, browser-url-ok, or normalize-url. The description gives the basic purpose but no selection criteria or alternative 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?

The annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the description adds only 'Title discarded after the call.' That note is vague and does not explain real behavior, especially since no schema parameter corresponds to 'title.'

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

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

The description is short and front-loaded, but it is under-specified rather than concise. The brevity omits essential details about required input and return value, making it insufficient for invocation.

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 unrelated parameters and no output schema, the description should explain what input represents a Wikipedia title and what the result looks like. It does neither, so the tool cannot be reliably invoked from the description alone.

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

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

Although all seven schema properties have descriptions, the description's core concept—'Wikipedia title'—is absent from the schema. The description fails to map 'title' to any parameter, leaving the agent unsure what input to provide.

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 clear at a high level, though it doesn't differentiate from siblings and the term 'title' never appears in the input schema, which creates ambiguity about how to invoke it.

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

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

There is no guidance about when to use this tool versus alternatives such as normalize-url, validate-json, or fetch-status. No usage conditions, exclusions, or prerequisites are provided.

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