ISO country MU

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

With no annotations, the description carries the full burden. It adds 'Task text discarded' and says what is returned, but it does not state whether the operation is read-only, whether external services are contacted, or what 'pay-per-call' implies for the caller.

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 short sentences with no filler: purpose first, then outputs, then caveat. 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?

This is a 9-parameter tool with no required fields, no output schema, and no annotations, yet the description gives no guidance about which parameters to use or how they map to the returned artifacts. The listed return items are named but not structured, leaving a large gap for an agent deciding 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?

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning; the only related note, 'Task text discarded', generalizes what the schema already says per-parameter.

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

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

The description names a specific verb and resource ('Find a public pay-per-call tool gateway (Monid)') and lists concrete return artifacts (CLI setup, how-it-works, skill file, remote MCP hops). This is easy to distinguish from the sibling validation and hint tools.

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

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

The only usage signal is implied: use this when you need a Monid gateway. There is no explicit when-to-use or when-not-to-use guidance, and no alternatives are named.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only reveals that no browser is launched; it does not state whether a network request is made, whether the check is purely syntactic, whether it resolves redirects, or what the return value indicates. This leaves important behavioral traits undisclosed.

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

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

The description is two short sentences with no filler. The core purpose is front-loaded, and the important caveat that no browser is launched is stated immediately and efficiently.

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 check tool with fully documented optional parameters, the description is minimally adequate: an agent knows the core operation and that no browser is involved. However, there is no output schema and no behavioral detail about the check itself, so the context is not fully complete for confident invocation.

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

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

The input schema already documents all 9 parameters with descriptions, including which ones are discarded, so schema coverage is 100%. The description itself adds no parameter-level meaning beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description states a specific action (check whether a URL can be opened) and a key distinguishing trait (no browser is launched), which separates it from browser-based siblings like playwright-url-ok. However, 'can be opened' is ambiguous: it could mean URL syntax validation or actual network reachability, and the description does not clarify what the check entails.

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

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

The phrase 'No browser is launched' implies this is a lightweight, non-browser alternative to other URL-checking tools, giving some usage context. But no explicit guidance is provided about when to choose this tool over siblings such as normalize-url, fetch-status, or playwright-url-ok, and no exclusions or alternatives are named.

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

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

With no annotations, the description must carry the full behavioral burden. It does disclose that the expression is discarded, which is a small transparency signal, but it says nothing about side effects, return values, failure cases, or whether the operation is read-only. The procedure itself is under-specified.

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

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

The description is very short and front-loaded; the two sentences contain no filler. However, the second sentence is vague and does not earn its place by meaningfully clarifying behavior, preventing 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?

Given nine parameters, no annotations, and no output schema, this description is severely incomplete. It fails to explain which parameter carries the arithmetic expression, what the output looks like, or how the tool behaves. An agent cannot invoke this tool correctly based on the provided definition.

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

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

The description mentions an arithmetic expression, but the input schema contains nine parameters (ref, url, city, feed, host, json, path, zone, query) that have nothing to do with arithmetic. Schema coverage is 100%, yet none of those parameters connect to the described purpose, so an agent cannot map the description onto any actual 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 operation ('Evaluate a+b style arithmetic') and thus distinguishes from sibling shape/status tools. However, 'Expression discarded' muddles what the tool actually does or returns, and the input schema contains no expression parameter, so an agent cannot confidently determine what to call it with.

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 any sibling tool. The description gives no context, exclusions, or alternatives, so an agent has to guess when arithmetic evaluation 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?

The description adds one useful behavioral fact: 'Page content is not stored.' However, with no annotations available, it omits other important traits such as whether a network request is made, whether redirects are followed, what errors can occur, and what side effects might happen. The disclosure is minimal for a tool that interacts with URLs.

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

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

The description is two short sentences with no filler; the primary operation is front-loaded and the storage disclaimer is a meaningful non-obvious detail. 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?

With nine parameters, no annotations, and no output schema, a two-sentence description is not complete enough to drive correct invocation. The description does not clarify why parameters such as city, feed, json, ref, and path exist, nor does it specify the expected output structure. An agent would likely need to guess or inspect sibling 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?

All nine parameters already have individual descriptions in the schema, so the baseline is a passing score. The tool description only elaborates on 'URL' semantics and does not explain how the other eight parameters relate to the stated purpose or whether they are required, so it adds little 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 uses a specific verb ('Return') and a concrete resource ('a URL'), and it names three observable outputs: host, scheme, and HTTP status. This makes the core purpose clear, though it does not explicitly compare against siblings like fetch-status, browser-url-ok, or 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 gives no guidance about when to use this tool instead of alternatives such as fetch-status, browser-url-ok, normalize-url, or web-fetch. An agent cannot infer selection criteria or exclusion conditions from the text.

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 identifiers are retained, a useful privacy behavior. However, with no annotations, it does not clarify whether this is a read-only classification, how inputs are processed, or what the response looks like. The schema's 'discarded' notes are not part of 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 short and front-loaded, with no redundant prose; the privacy note earns its place. It is slightly under-sized for a 9-parameter tool, but each sentence carries weight, so it remains structured and efficient.

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

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

For a tool with 9 optional parameters, no output schema, and no annotations, this description is inadequate. It does not explain the classification output, the relationship among parameters, or how the tool relates to sibling tools, leaving an agent with only disjointed schema notes.

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 of 3 applies. The description adds no parameter-level meaning, but the schema already documents each parameter's purpose and discard behavior, so no extra compensation is needed.

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

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

The description states a specific action ('Show how this request is classified') but does not define what 'classified' means or what the output categories are. It is not a tautology, but it is too vague to distinguish this tool from sibling shape-check tools like domain-shape or validate-json.

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

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

No guidance is provided about when to use this tool versus sibling alternatives. The description does not mention exclusions, conditions, or alternative tools, leaving an agent to guess whether compatibility is a dispatcher or a check.

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 behavior disclosure. It communicates a pure transformation but fails to mention the tool's broader behavior: the schema shows many unrelated inputs that are 'discarded after the shape check', and there is no indication of return values 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 a single front-loaded sentence with no filler and a useful scoping clause. It is appropriately concise, though the extreme brevity contributes to the completeness gap.

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

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

For a tool with nine optional parameters, no annotations, no output schema, and a family of sibling shape tools, one sentence about hostname splitting is inadequate. It does not explain the overall purpose, the role of the other parameters, what output to expect, or when it should be preferred.

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 even without parameter details in the description. The description adds nothing beyond the schema and creates friction by mentioning only the hostname while the schema exposes eight other parameters, but the schema descriptions themselves are informative.

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

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

The description states a specific verb and resource ('Split a hostname into labels') and adds a scope boundary ('without WHOIS or ownership data'). It is clear at a glance, though it does not explicitly differentiate itself from sibling shape-check 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 phrase 'Split a hostname into labels' implies when to reach for it, and 'without WHOIS or ownership data' gives a negative boundary against ownership-lookup use cases. However, it never names alternatives or states explicit conditions for choosing this tool over sibling tools like figma-url-shape or github-repo-shape.

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 transparently discloses the HTTP method (HEAD) and that the tool returns status only, which tells the agent not to expect a response body. With no annotations, it still leaves undefined behavior for invalid URLs, redirects, network errors, and why multiple schema parameters are described as discarded.

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

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

One sentence with no filler and the key constraint ('status only') is front-loaded. The description is economical and easy to parse.

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, zero required parameters, no output schema, and no annotations, the description must explain how to select inputs and what the returned status looks like. It only covers the URL case and leaves the remaining parameters unexplained, so an agent cannot reliably determine full usage.

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

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

Schema description coverage is 100%, so the baseline is 3; every parameter already has a description. The tool description adds little beyond 'public URL' and does not clarify how the other eight parameters relate to the stated HEAD operation.

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: HEAD a public URL and return only the status. This is a clear verb+resource statement, not a tautology. It does not, however, differentiate itself from sibling URL-checking tools like browser-url-ok or web-fetch, and it omits the other input parameters visible in the schema.

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

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

There is no guidance on when to prefer this tool over alternatives, no exclusions, and no mention of which of the nine optional parameters should be supplied. 'Public URL' is a scope hint, not usable selection 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 full burden, but it discloses only that 'Path discarded' without explaining whether the tool validates, normalizes, returns a parsed object, or performs a network request. The behavior of the `url` parameter and the fate of the other eight input parameters is left 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 short and front-loaded, but the cryptic second sentence 'Path discarded.' reads as under-specification rather than useful brevity. It earns a middle score because there is no wasted prose.

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, no annotations, and 26 sibling tools, the description is too thin for an agent to invoke correctly with confidence. It does not state what the parse result is, which field carries the Figma URL, or how this differs from URL-normalizing siblings.

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

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

Although schema coverage is 100%, the schema contains eight parameters (ref, city, feed, host, json, path, zone, query) that appear unrelated to a Figma URL parse, and the description does not identify `url` as the relevant parameter or dismiss the others. The 'Path discarded' phrase conflicts with the schema's `path` parameter description ('File path to check'), making invocation 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 names a specific verb and resource ('Parse a Figma file URL'), which is enough to distinguish this from sibling tools like github-repo-shape or jira-key-shape. The trailing 'Path discarded.' is vague, but it does not obscure the core purpose.

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

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

There is no guidance about when to choose figma-url-shape over alternatives such as normalize-url or browser-url-ok. The description only implies a Figma URL input; it provides no conditions, exclusions, or prerequisite 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?

With no annotations, the description carries the full behavioral burden. It usefully discloses 'No disk access', implying the check is side-effect-free and purely syntactic, but it does not describe what happens on success/failure, whether it returns a boolean, or what 'safe' entails.

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

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

Two short sentences with no filler: the first names the action and target, the second adds the key no-I/O constraint. 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 simple predicate, the description is minimally adequate: it names the purpose and the no-disk-access boundary. Yet with no output schema and no annotations, the agent still lacks the exact return contract and the definition of a 'safe' path, so the description is not fully complete.

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% parameter description coverage, so the baseline is 3 and the description does not need to repeat parameter details. However, the schema exposes many unrelated optional properties, and the description offers no guidance about which parameter is relevant, creating mild ambiguity despite the path property itself being documented.

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 ('Check'), a resource ('path'), and a criterion ('looks safe'), which is enough to distinguish it from URL-focused siblings like browser-url-ok. It does not, however, define what 'safe' means or what the tool returns, so it stops short of fully 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 guidance is given about when to use this tool versus alternatives such as the other shape-checking siblings. 'No disk access' hints that it is a lightweight validation step, but the description never states a preferred use case, 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?

With no annotations, the description carries the full burden of behavioral disclosure, but it only says the tool returns coordinates. It does not mention the likely external Open-Meteo network call, how inputs are handled, or any side effects or return 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 compact sentence with no wasted words and easily front-loaded information. However, given the tool's 9-parameter schema and lack of annotations, this brevity may under-serve the agent's need for context.

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

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

There is no output schema or annotations, and the one-sentence description does not explain what the tool returns, how to specify the place among the 9 optional parameters, or how it relates to sibling hint tools. This is 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 input schema has 100% parameter description coverage, so the baseline is 3. The description adds no parameter-level meaning and notably fails to indicate which parameter represents the 'place' (likely city), leaving interpretation to the schema.

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

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

The description states the tool provides latitude and longitude for a place via Open-Meteo, which communicates a clear resource and outcome. However, it lacks an explicit verb and does not differentiate it 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?

The description gives no guidance about when to use this tool versus alternatives such as weather-hint, timezone, or iana-zones. There is no mention of use cases, prerequisites, or exclusions, leaving the agent without routing information.

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 communicates the core parse behavior, but it doesn't state whether invalid URLs error or how the parsed result is returned, nor does it note that unrelated schema fields are ignored.

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

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

A single sentence with no filler. The verb, input, and output are front-loaded and nothing in the description is wasted.

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 adequate for a simple parser but leaves gaps: there is no output schema, so the return value is not formally described; no annotations cover safety; and the schema's nine optional fields make it unclear which are used. The tool name and description compensate enough to be usable, but not fully complete.

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 a baseline of 3 applies. The tool description adds GitHub-specific intent to the generic 'url' parameter, but it doesn't explicitly mark url as the required logical input or clarify which of the 9 optional properties are 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 specific verb ('Parse'), the resource ('GitHub URL'), and the expected result ('owner and repo'). It cleanly distinguishes this tool from sibling shape tools such as domain-shape, figma-url-shape, and jira-key-shape.

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 clear context: use this tool when a GitHub URL needs to be reduced to owner/repo. It doesn't explicitly name alternatives/exclusions, but the use case is concrete enough that an agent can route to it without much inference.

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

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

No annotations are provided, so the description carries the full burden. It does disclose one useful behavior: titles are discarded and only a count is returned, and 'current' implies a live snapshot. However, it does not mention output shape, side effects, error behavior, or whether network access is required.

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

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

The description is very short, front-loaded with the verb and object, and contains no filler. It loses one point because, after reading the nine-parameter schema, the terseness starts to become under-specification rather than efficient 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?

There is no output schema and no annotation support, and the description does not state the return format, which parameter to use, or behavior with no arguments. With nine mostly unrelated optional parameters and no connection to Hacker News, the context is 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?

Schema description coverage is 100%, which normally sets a baseline of 3, but the description adds no parameter meaning. The nine optional string parameters (ref, url, city, feed, host, json, path, zone, query) are not connected to the described Hacker News front-page count, so an agent cannot determine which parameter selects the source.

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 ('Count') and resource ('current Hacker News front-page stories'), and clarifies that titles are discarded. This unambiguously defines the tool's core operation.

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?

'Titles discarded' gives an implicit hint that this tool is for obtaining counts rather than titles, but the description provides no explicit when-to-use guidance, no alternatives, and no exclusion conditions relative to the sibling tools.

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

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

With no annotations, the description must carry behavioral disclosure. It implies a read-only lookup of timezone names, but does not state what is returned, how it behaves with inputs, or whether it has side effects. The input schema reveals many parameters are 'discarded,' yet the description does not clarify 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 compact sentence with no filler and the core domain is front-loaded. It sacrifices completeness for brevity, but structurally it is clean.

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, and no output schema, this one-line description is under-specified. It does not explain the return format, the role of the parameters, or how the timezone list is produced, so an agent lacks enough context to invoke it confidently.

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

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

Schema description coverage is 100%, so the baseline is 3 even without parameter information in the description. Each schema property is individually documented, though the description adds no value in explaining why a timezone-name tool accepts ref, url, city, feed, host, json, and path.

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

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

The description identifies a resource—common IANA timezone names—and its intended use for clock calls, which loosely separates it from siblings like timezone and utc-time. However, it lacks an explicit operation verb (returns? lists? validates?), 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?

There is no guidance on when to use this tool versus sibling tools. It does not mention timezone or utc-time as alternatives, nor does it state conditions for using this list instead of direct clock calls. 'For clock calls' is only a weak contextual hint.

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

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

Annotations are absent, so the description carries the full burden. It does disclose a meaningful behavior: returning only group counts rather than full robots.txt content. However, it does not mention error handling, redirects, or what happens with the many unrelated input parameters.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to the tool's core behavior.

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

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

Given 9 optional parameters, no annotations, and no output schema, this description is too sparse to be fully actionable. It fails to specify which parameter contains the robots.txt URL, how the other parameters should be handled, and the exact structure of the returned group counts.

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

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

The input schema has 100% description coverage, so the baseline is 3. The tool description adds no parameter mapping, and crucially it does not identify which of the 9 optional parameters is the robots.txt URL, leaving the agent to infer from the schema's generic 'HTTPS URL' text.

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

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

The description states a specific action ('Fetch a public robots.txt') and a clear result ('return group counts only'). However, it does not differentiate this tool from sibling fetch/status tools such as 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?

No guidance is given about when to use this tool versus alternatives like web-fetch, normalize-url, or fetch-status. The phrase 'public robots.txt' implies a use case, but there are no explicit conditions, exclusions, or routing hints.

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

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

The description discloses that the key is discarded, which is useful side-effect information and partially compensates for the lack of annotations. However, it does not explain what constitutes a valid Jira key shape, what gets returned, or what happens on invalid input, leaving the core behavior under-specified.

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 primary purpose is front-loaded. Both sentences earn their place: one defines the action, the other clarifies data handling.

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 return-format description, the agent is left without expectations for the result. The description also fails to connect the Jira key to the actual schema parameters, making the tool difficult to invoke correctly without prior knowledge.

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 seven parameters with detailed descriptions, but none of them is named or described as a Jira key. The description's 'Key' concept does not map to any input schema field, so despite the high schema coverage, the agent cannot determine which parameter to pass.

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

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

The description states a specific verb ('Check') and a specific resource ('Jira issue key shape'), which clearly distinguishes it from sibling tools like github-repo-shape or domain-shape. The additional phrase 'Key discarded' also signals a read-only validation action.

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

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

The intended use is clear: validate a Jira issue key's shape. However, there is no explicit guidance about when to prefer this tool over alternatives, nor any when-not-to-use or exclusionary notes. It relies on the implicit context of the tool name.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds one useful trait (body discarded), but omits essential behavior: whether this performs a live network request, redirect handling, timeout behavior, error-status semantics, and why nine heterogeneous parameters are accepted when most 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?

Two short sentences with no filler, and the key output (HTTP status) is front-loaded. However, the brevity reads more like under-specification than disciplined conciseness, omitting critical usage and parameter context that the rest of the definition fails to provide.

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

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

For a tool with 9 parameters, no annotations, and no output schema, this description is far from complete. It names the bare output type, but an agent has no way to understand which parameter drives the check, how the other eight are handled, or what distinguishes a valid from an invalid call.

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%, which sets a baseline of 3, but the description fails to connect its stated purpose to any of the nine parameters. The parameters (city, zone, json, query, feed, ref, path, host) appear to belong to other sibling tools, and the url description ('normalize or cite') conflicts with the docs-URL status purpose, leaving an agent unable to tell which parameter is actually meaningful.

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

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

The description states a specific action and resource: getting the HTTP status of a public library docs URL, with the body discarded. However, it does not differentiate from URL-related siblings like fetch-status, browser-url-ok, or web-fetch, which plausibly overlap the same use case.

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 its 26 siblings, several of which (fetch-status, browser-url-ok, web-fetch, normalize-url, domain-shape) likely cover identical HTTP-status or URL-inspection scenarios. The 'hint' name suggests a specialized role, but the description never states the selection condition 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?

With no annotations, the description carries the behavioral burden, and 'Values discarded' is a useful signal that this is a read-only style operation returning only a count. However, it does not mention output format, edge cases, or whether the count is top-level only, leaving some behavioral ambiguity.

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

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

The description is a single sentence with no wasted words. The core verb and resource are front-loaded, and 'Values discarded' is placed right after the main behavior.

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

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

For a simple counting tool, the one-liner is nearly adequate, but the definition does not explicitly map the operation to the `json` parameter or describe the return value. With many sibling tools and no output schema, the invocation contract is minimally specified rather than fully complete.

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 description is not required to repeat param docs and the baseline is 3. The description adds no specific parameter guidance, such as clarifying that the `json` string is the value to count.

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 keys') and resource ('a JSON object'), and 'Values discarded' adds useful scope. It does not, however, contrast with sibling tools such as validate-json or domain-shape, so it earns a 4 rather than 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?

Usage is only implied by the verb: an agent would infer it should use this tool when it needs to count keys in a JSON object. There is no explicit mention of when not to use it or which sibling alternative to choose 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?

With no annotations, the description carries the full burden, and it does disclose the core behavior: only origin, host, and path are returned, while query and fragment are dropped. But it does not say whether the URL is fetched or validated, how invalid input is handled, or what happens with the nine optional schema parameters, leaving the behavior 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 a tight two-sentence definition with no filler. It front-loads the return contract and immediately states the important drop behavior, so 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?

There is no output schema and no annotations, so the description must specify the return format and correct invocation. It names the output components but not their shape, and with nine optional parameters and zero required parameters, it does not tell an agent that only 'url' is relevant, which is a significant completeness gap.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the tool description adds no parameter-level detail. The description implies that 'url' is the meaningful input, but it does not reconcile the schema's many unrelated optional parameters such as city, json, zone, and query, which weakens invocation clarity.

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

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

The description states a specific verb ('Return') and names the resource and outputs ('origin, host, and path for a URL'), so it is clearly not a tautology. It also adds the key behavior that query and fragment are dropped. However, it does not explicitly differentiate itself from URL-related siblings 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?

The intended use is implied: call this when you need the origin, host, and path of a URL, and avoid it if you need query or fragment values. But there is no explicit when-to-use or when-not-to-use guidance and no named alternative among the many URL-adjacent sibling tools, so routing is left to inference.

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

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

The description discloses one important behavioral trait: no browser is launched. However, with no annotations at all, the description carries the full burden, and it does not mention whether any network request is made, how 'can be opened' is determined, what side effects exist, or what the return value looks like.

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

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

The description is short and front-loaded, with no filler words. However, given the nine-parameter schema and the absence of an output schema, this level of brevity leaves important information out.

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

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

The tool is not contextually complete for an agent: there is no output schema, no annotations, and the description does not explain which parameter should be used, what result indicates success, or how the URL check relates to the other accepted parameters. The 'No browser is launched' note is useful but 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 structured schema already documents all nine parameters. The tool description adds no parameter-level meaning, and it does not clarify how the many unrelated-looking parameters (city, feed, json, path, zone, query) relate to checking a URL.

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 ('Check') and resource ('whether a URL can be opened'), which gives a usable sense of the tool's purpose. The added note 'No browser is launched' helps differentiate it from browser-based checks, though it does not explicitly name sibling tools or fully define what 'can be opened' means.

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

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

There is no guidance on when to use this tool versus alternatives such as browser-url-ok, fetch-status, or normalize-url. The description implies a lightweight URL check, but it never states the conditions under which an agent should choose this 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?

The description explicitly says 'Query discarded,' which discloses a meaningful side-effect trait—input is not persisted—and implies a read-only length computation. However, it does not explain behavior when multiple parameters are provided or describe what the returned length looks like, and no annotations exist to fill that 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 only two sentences, with the action front-loaded and the side-effect statement following directly. Every word earns its place, though its brevity contributes to the ambiguity 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 nine optional parameters, no output schema, and no annotations, the two-sentence description is insufficient. It does not explain the role of the extra parameters, the return format, or what happens if multiple properties are supplied, making the tool hard to invoke confidently.

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

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

Schema description coverage is 100%, so the baseline is 3. The phrase 'search query' aligns with the `query` property description ('Search text; discarded after the length check'), adding slight meaning. But the description fails to address the other eight parameters or specify which one carries the search query, leaving potential for misuse.

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

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

The description states a specific verb ('Count') and resource ('characters in a search query'), which clearly differentiates it from sibling counting tools like memory-key-count or hn-front-count. However, the nine-parameter schema creates ambiguity about which input actually represents the search query, so it is not perfectly precise.

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, nor any conditions, prerequisites, or exclusions. The description simply states what it does, leaving the agent to infer the appropriate context from the tool name.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotenceHint=true, so the description adds very little behavioral context beyond saying the content is 'short' and covers 'common' codes. It does not disclose return format, pagination, or input behavior, and it does not contradict the annotations.

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, which is concise, but it is under-specified rather than efficiently complete. It front-loads the basic catalog idea but does not earn its place as the sole description for a tool with seven parameters and no output 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?

For a tool with seven unrelated input properties, no output schema, and many sibling tools, a one-line content label is insufficient. It does not explain what the tool returns, whether any parameter is required, or how inputs such as city, feed, json, and path relate to HTTP status codes.

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 every one of the seven properties has its own description, so the schema already carries the parameter documentation burden. The tool description contributes no additional meaning about how ref, url, city, feed, host, json, or path relate to the catalog, 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 is a noun phrase, not a verb+resource statement, and it largely restates the tool name: 'status-catalog' becomes 'catalog of common HTTP status codes.' It narrows the domain to HTTP status codes, but it does not say whether the tool returns, filters, or inspects anything, and it does not distinguish this from sibling tools like 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 when-to-use guidance, no exclusions, and no mention of alternative tools. An agent is not told why it should call status-catalog instead of a sibling such as fetch-status or domain-shape, so the description leaves usage entirely to inference.

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

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

No annotations are provided, so the description carries the transparency burden. It does disclose one important behavior: the prompt is discarded rather than used to customize the template. However, it does not clarify whether any of the nine parameters affect the result or describe side effects, leaving only 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?

Two short sentences, front-loaded with the main purpose and followed by a critical caveat. Every word earns its place; there is no padding 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?

The schema provides good coverage of the nine optional parameters, but the description does not explain what the returned template contains, whether to pass any arguments, or how parameters marked as non-discarded relate to the template. This is a serviceable description, but material ambiguity remains.

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 input schema already documents every parameter, including that many are discarded after a shape check. The description adds no parameter-level meaning, which is acceptable under the baseline but earns no extra credit.

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

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

The description clearly states a concrete action and resource: 'Return a three-step thinking template.' This is distinct from the many validation/utility sibling tools, but it does not explicitly name or differentiate itself from a sibling, 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 about when to use this tool instead of another, no exclusions, and no comment on whether arguments should be supplied. 'Prompt discarded' is a caution, not a usage policy; the agent is left to 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?

With no annotations, the description carries the burden, but it only states the core behavior: returning current time. It does not disclose output format, error behavior for unknown timezones, or that non-zone parameters are discarded, though these are relatively minor for a read-only time lookup.

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 and front-loads the core idea ('Current time') before the scope ('in a named IANA timezone').

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 tool, the description plus a 100%-documented schema is mostly sufficient to select and invoke it. It does not state the return format or explicitly mark the zone parameter as required, but the phrase 'named IANA timezone' and the schema's zone description make the main call path clear.

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

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

Schema description coverage is 100%, and the zone property already says 'IANA timezone name', so the description adds little beyond the schema. It reinforces the idea of a named IANA timezone but adds no new parameter semantics or examples.

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 time for an IANA timezone, which is distinct from siblings like iana-zones (listing zones) and utc-time (UTC time). It lacks an explicit verb like 'returns' or 'gets', so it is clear but slightly less precise than a full verb+resource statement.

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 phrasing implies use when a current time in a specific IANA timezone is needed, but it does not mention alternatives, exclusions, or when to prefer utc-time or iana-zones. No explicit when-to-use or when-not-to-use guidance is provided.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It only says the tool returns a current UTC timestamp, but does not disclose the output format, precision, whether parameters are ignored, or any side effects. This is insufficient for an agent to fully predict the tool's 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, direct sentence with no filler. It is appropriately brief for a simple time utility, though it could be more helpful by specifying the output format or a parameter note without much added length.

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 lack of an output schema, lack of annotations, and a puzzling input schema with several seemingly unrelated parameters, the description is not complete enough for correct invocation. An agent still cannot tell what the return value looks like or whether to pass any arguments.

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 input schema properties already have descriptions, so the schema coverage is high and earns a baseline of 3. The tool description adds no clarification about whether any of these parameters matter for utc-time, but the schema itself documents each field's role, including which values are discarded.

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

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

The description states the tool provides the current UTC timestamp, which is clear and specific enough to understand its basic function. However, it does not distinguish it from sibling time-related tools like timezone or iana-zones, and it lacks an explicit verb showing the action.

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 timezone, iana-zones, or other siblings. The description does not mention exclusions, alternatives, or context clues such as whether the agent should use this for display timestamps, logging, or comparisons.

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 side effect: 'The body is discarded.' However, it does not explain what happens when JSON is invalid, what the return value is, or whether other side effects exist, 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 the main purpose front-loaded and no extraneous words. Every phrase earns its place, making this an efficient, well-structured description.

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

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

There is no output schema or annotations, so the description should explain return behavior and invocation details. It does not mention what the tool returns, which parameter to supply, or edge cases, and the many unrelated schema fields further increase the need for context that is not provided.

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 schema properties have detailed descriptions, so schema coverage is high and the baseline is 3. The description adds no parameter-level insights, only an abstract reference to 'body' that does not directly map to any schema property.

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 ('Check') and resource ('whether a body is valid JSON'), making the primary purpose unambiguous. However, 'body' is not defined and no distinction is made from sibling tools, so it falls slightly short of perfect 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 provides no guidance on when to use this tool versus alternatives. It does not mention conditions, exclusions, or any sibling tools, leaving the agent to infer appropriate 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?

No annotations are provided, so the description must carry full behavioral disclosure. It does reveal an external dependency on Open-Meteo and implies a read-only operation, but it does not mention error behavior, result format, units, or that unrelated schema parameters are discarded. This is insufficient for confident invocation.

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 that directly states the core purpose with no filler. It is concise and easy to scan, though it is so terse that it leaves important invocation details to the schema.

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

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

This tool has nine optional parameters, no annotations, and no output schema, yet the description offers only one sentence. There is no explanation of the expected response beyond 'current temperature', no unit or error context, and no clarification of the relevant parameter among many discarded ones. This is incomplete for reliable tool selection and invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds only that the temperature is for a city via Open-Meteo, which is minor context beyond the schema. It does not clarify why the unrelated parameters exist or which parameter is needed, but the schema itself already documents each property.

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 resource and scope: 'Current temperature for a city' via Open-Meteo. This makes the tool's function clear and distinguishes it from the sibling list, where no other tool is weather-specific. It loses a point because it is a noun phrase rather than an explicit verb, and the large unrelated input schema slightly muddies the tool's actual focus.

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, nor any instruction that `city` is the only relevant parameter. The eight other schema properties are documented as discarded, but the description itself provides no direction on invocation, leaving an agent to infer how to call the tool correctly.

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 clearly discloses that the response body is discarded, which is valuable and not visible from the schema alone. It does not mention redirects, timeouts, error behavior, or whether it only performs a GET request.

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

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

A single, front-loaded sentence with no filler. Every clause adds meaning: the outcome, the URL scope, and the discarded body.

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

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

The definition is enough for a simple status-and-content-type fetch, and the schema covers the parameters. But with no annotations, no output schema, and several similarly named sibling tools, the description is too sparse to fully disambiguate behavior around errors, redirects, and when the other input fields matter.

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

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

Schema description coverage is 100%, so the schema already documents all 9 parameters in detail. The description adds only the general 'public URL' context and does not clarify which parameter is the primary fetch target or how the additional parameters interact with fetching.

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 outcome: HTTP status and content type for a public URL, with the body discarded. This names the resource and the core return values, though it does not explicitly distinguish itself from the similar sibling 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 public URL' gives a usage context and implies it is appropriate when only status and content type are needed, not full content. However, it does not explicitly state when to prefer this tool over siblings like fetch-status or browser-url-ok.

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 does add one behavioral note beyond the schema: 'Title discarded after the call.' But with no annotations and no output schema, it fails to disclose return values, what 'exists' means, or how the check relates to the seven provided parameters. The missing title-input mapping leaves behavior 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 short, front-loaded, and free of filler; the first sentence states the core action and the second adds a retention note. It is concise, though the second sentence is not well connected to the schema, so efficiency slightly outpaces useful structure.

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 seven parameters, no annotations, and no output schema, yet the description never bridges the gap between 'Wikipedia title' and the available inputs. An agent cannot determine what to pass or what result to expect, making the definition inadequate 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 describes each parameter individually, but the tool's central concept—the Wikipedia title—appears in the description while no schema property is named 'title'. The description does not explain which of ref, url, city, feed, host, json, or path should carry the title, so it creates confusion rather than adding 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 states a specific operation and resource: 'Check whether a Wikipedia title exists.' This is distinct from sibling checker tools like file-path-ok or github-repo-shape. However, the description does not map the stated title check to any schema parameter, which weakens its practical 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?

Usage context is only implied by the phrase 'Check whether a Wikipedia title exists.' There is no explicit guidance about when to choose this tool over related validators, no prerequisites, and no conditions that would make a sibling tool more appropriate.

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