ISO country PN

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

There are no annotations, so the description carries the burden. It discloses two useful behavioral traits: the target gateway is pay-per-call (cost implications) and 'Task text discarded' (input text is not preserved/used). It stops short of stating auth needs, network behavior, or exact side effects, but this is meaningful beyond the schema.

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

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

Two short sentences, with the core purpose and output front-loaded. It is concise and avoids filler, though the 'Task text discarded' sentence is terse and could be expanded slightly to clarify its meaning.

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

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

With six parameters, no output schema, and no annotations, the description needs to explain how to invoke the lookup and what 'returns ... remote MCP hops' means in practice. It lists output categories but does not say which parameter is required, how the inputs map to a gateway, or what the returned skill file/CLI setup looks like, so an agent would likely guess.

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

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

Schema description coverage is 100%, so the baseline applies: the schema already documents each of the six parameters. The description itself adds no parameter-level detail; the only global hint, 'Task text discarded', is also echoed in the parameter descriptions. No contradiction, but no extra value above 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 ('Find') and a concrete resource ('public pay-per-call tool gateway (Monid)'), and it lists the artifacts returned (CLI setup, how-it-works, skill file, remote MCP hops). This is not a tautology and gives an agent a clear idea of the tool's function, though it does not explicitly contrast with the sibling validator/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 intended use case is implied by the first sentence: an agent should use this when it needs Monid gateway setup or remote MCP hop information. However, there is no explicit guidance about when not to use it or how it differs from the many sibling tools such as lib-docs-hint or web-fetch.

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

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

With no annotations, the description must carry the behavioral burden. It does disclose one useful safety property ('No browser is launched'), but it leaves unclear whether a network request is made, whether the check is purely syntactic, and how invalid or unsupported URLs are handled. 'Can be opened' is ambiguous about actual 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 two short sentences with no filler, and the no-browser caveat is placed immediately after the main claim, so it is well front-loaded. However, it is arguably under-specified for a tool with nine parameters and many sibling tools, so it is not a perfect 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?

There is no output schema, no annotations, a nine-parameter input schema, and many overlapping siblings. The description omits the return value or format, does not identify which parameter is the intended URL input, and does not explain how the non-URL parameters should be treated. This is insufficient 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?

The input schema provides 100% parameter description coverage, including lifecycle hints like 'discarded after the shape check' and 'no disk access.' The top-level description adds no parameter-level meaning, but with full schema coverage the baseline of 3 is appropriate.

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

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

The description states a clear verb and resource: it checks whether a URL can be opened, and it adds a meaningful constraint with 'No browser is launched.' It does not explicitly distinguish itself from overlapping siblings like normalize-url, fetch-status, or playwright-url-ok, and the 9-parameter schema adds ambiguity about which input is actually used, 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 versus any of the 27 sibling tools. It does not mention whether this is a pre-flight check before fetch-status/web-fetch, an alternative to playwright-url-ok, or simply a URL-shape validator, so an agent must infer the intended 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?

With no annotations, the description must disclose side effects, return behavior, and failure modes itself. It only states that the expression is discarded; it does not say what is returned, whether evaluation actually produces a result, or how malformed expressions 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 short and front-loaded with the verb, and both sentences are terse. However, the cryptic "Expression discarded" spends scarce space without clarifying the core behavior, making the brevity more harmful than helpful.

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

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

Nine optional parameters, no output schema, and no annotations put a heavy burden on the description. It fails to identify which parameter carries the arithmetic expression, what result or confirmation to expect, or how the tool relates to the sibling tools, so it is not usable as the sole contract.

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

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

Schema coverage is 100%, so the nine parameters already have individual descriptions; the description adds no parameter-level meaning and never connects the mentioned expression to any schema property. The baseline of 3 applies, though the mismatch is a real usability gap.

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

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

"Evaluate a+b style arithmetic" names a concrete action and a specific input domain, so an agent can identify this as an arithmetic-evaluation tool. It falls short of full clarity because "Expression discarded" is cryptic and no sibling differentiation is offered, but it is not a tautology or vague.

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

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

The description gives no explicit when-to-use guidance, prerequisites, or alternatives among the many sibling tools. The a+b phrasing weakly implies a use case, but an agent gets no help deciding between calc-eval and the other validation/shape-check tools.

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

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

The description adds a useful behavioral guarantee: page content is not stored. With no annotations available, this helps the agent understand privacy and side-effect expectations. Still, it does not disclose whether a network request is made, whether inputs are retained, or what the exact return shape is beyond the three headline fields.

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: the primary output is stated first, and the privacy caveat follows in a tight second sentence. It has no filler, though it is terse relative to the large optional parameter set.

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 multi-parameter optional tool with no output schema, this description is incomplete. It does not explain the role of the many non-URL parameters, what 'citation' means in this context, or how results are returned. The non-storage note is useful but does not fill the 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?

The input schema already provides descriptions for all parameters, so the baseline is 3. The tool description only references 'a URL' and adds no extra meaning for parameters like ref, city, feed, host, json, or path. It does not contradict the schema, but it also does not help the agent reason about which parameters are relevant for a given 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 clearly states a concrete verb and resource: return host, scheme, and HTTP status for a URL. It is not a tautology and gives the agent a specific sense of the tool's output. However, it does not explicitly differentiate from sibling tools like fetch-status or normalize-url, which may also operate on URLs.

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 fetch-status, normalize-url, web-fetch, status-catalog, or other URL-related siblings. The 'page content is not stored' note is a behavioral statement rather than a usage condition or alternative-selection heuristic.

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 disclosure burden. It does disclose a meaningful privacy trait: 'No identifiers are retained.' This is reinforced by the per-parameter schema descriptions saying values are 'discarded.' However, it does not state whether the tool performs external calls, whether it is read-only, or what the classification output contains—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?

The description is two short sentences with no filler. The core purpose is front-loaded first, and the privacy statement is a separate crisp sentence. Every word earns its place.

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

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

Given nine heterogeneous optional parameters, no output schema, and no annotations, the description is too terse to be complete. It leaves undefined what classification results look like, how the tool should be invoked with multiple fields, and what the agent should do with the response. The privacy note is valuable, but an agent still lacks enough context to confidently interpret the 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%, and the schema already explains each parameter's purpose and discarding behavior. The tool description adds no additional parameter-level meaning. Baseline 3 is appropriate because the schema does the heavy lifting and the description does not introduce ambiguity or contradict 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 an action ('Show') and an object ('how this request is classified'), which is more than a tautology. However, 'classified' is never defined—there are no categories, labels, or examples—and the tool is not differentiated from many sibling tools that also inspect request-like data (e.g., validate-json, domain-shape, normalize-url). An agent can tell this tool performs classification, but not what classification means here.

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

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

No guidance is given for when to use compatibility versus any of the sibling tools. There are no explicit alternative names, no conditions, and no exclusions. The input schema suggests any of nine optional fields may be supplied, but the description does not clarify which types of requests or use cases this tool is meant for.

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 behavioral burden. It adds one useful negative ('without WHOIS or ownership data'), but it does not disclose whether the tool performs network access, what happens to the input parameters, or the shape of the result, which is a significant gap for a no-annotation tool.

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 wasted words; the core operation is front-loaded and the caveat about WHOIS/ownership follows immediately.

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 needs to communicate return values and invocation expectations, but it only states a basic operation. The nine optional parameters and sibling tools make the one-sentence description insufficient for confident invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's 'hostname' points toward the `host` property, but it adds no detail on format, requiredness, or how the other eight optional parameters relate to the 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 uses a specific verb and resource: 'Split a hostname into labels', and the 'without WHOIS or ownership data' clause makes clear this is a purely lexical operation, not a domain lookup. It does not name sibling shape tools, but the hostname scope is unambiguous enough to distinguish 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?

It gives a direct, clear context for use: an agent should reach for this tool when it needs hostname labels, and the 'without WHOIS or ownership data' boundary warns against using it for ownership info. It stops short of a 5 because it never names alternatives such as normalize-url 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?

No annotations are provided, so the description carries the behavioral disclosure burden. It clearly discloses the HTTP method (HEAD), the public scope, and the limited return value. It does not discuss error behavior or ignored parameters, but the core side-effect-free behavior is 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 single front-loaded sentence with no filler, stating the action, target, and result 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 HEAD operation the description is mostly adequate, but without an output schema it could more explicitly define what 'status' means and which parameter should be supplied. The nine-parameter schema creates ambiguity that the one-line description does not fully resolve.

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

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

Schema coverage is 100%, so each parameter is already documented in the schema. The description adds no parameter-level detail beyond implying 'url' is the relevant one, and it does not clarify why the other parameters exist, but the schema handles their individual 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 uses a specific verb (HEAD), identifies the resource (public URL), and states the output (status only), making the core purpose clear. It does not explicitly contrast with sibling tools like browser-url-ok or web-fetch, so it is not fully differentiated.

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 wording implies the tool is for checking the HTTP status of a public URL, but it gives no explicit when-to-use or when-not-to-use guidance and names no alternatives. With many sibling tools, routing is left mostly to inference.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Path discarded' reveals one behavioral trait, but the description omits whether the tool performs network access, is read-only, what it returns, and what URL formats are accepted. For an unannotated tool, this is insufficient transparency.

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

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

The description is very concise and front-loaded with the main verb and resource. Every word earns its place, and there is no filler. The terseness does create ambiguity, but structurally it is 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?

Given no annotations, no output schema, and an input schema with nine mostly unrelated parameters, a seven-word description is not enough. The agent lacks guidance on which parameter to populate, what the tool returns, what URL shapes are valid, and whether any side effects occur. This 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 description adds little parameter-level meaning. 'Path discarded' merely restates what the path parameter's schema already says. The description also does not clarify which of the nine schema parameters is the intended Figma URL input or whether the others are ignored.

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.' This clearly distinguishes the domain from sibling tools like github-repo-shape or domain-shape. However, it does not say what the parse result is or what 'shape' means, and 'Path discarded' is cryptic rather than explanatory.

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

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

The usage context is implied by the Figma-specific subject: an agent would infer to use this tool when given a Figma file URL. There is no explicit guidance about when not to use it or how it compares to alternatives such as normalize-url or browser-url-ok, but the domain is specific enough to provide some direction.

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. 'No disk access' is a valuable explicit guarantee that this is a pure lexical check, but the description does not disclose what 'safe' means, what the return value is, or possible failure modes.

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 convey the core purpose and the key safety behavior with no filler. The most important phrase 'Check whether a path looks safe' is 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?

With no output schema, no annotations, and nine optional parameters, the description is too thin to be complete. It does not explain what a 'safe' path looks like, how the result is returned, or which fields are actually used, leaving meaningful ambiguity for an agent.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning beyond what the schema already provides for 'path,' and it does not address the other eight optional parameters 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 and resource: it checks whether a path looks safe. It also distinguishes itself from URL-focused sibling tools by clarifying this is about a file path and adds a behavioral boundary with 'No disk access.'

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 browser-url-ok or normalize-url. The phrase 'No disk access' hints that it is a pre-check, but it does not state when it should be preferred or what conditions make it insufficient.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It hints at an external Open-Meteo call but does not state whether the call is read-only, what side effects or network dependencies exist, what happens with the input, or how failures are handled. This is a significant gap for a tool with no 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, compact sentence with no filler, and the key idea is front-loaded. However, for a tool with nine optional parameters and no annotations, this brevity borders on under-specification; there is no additional structure to help the agent understand how to use it.

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 required fields, no output schema, and no annotations, a one-line description is incomplete. The agent cannot determine which parameter to populate, what the returned coordinate format is, or how errors are surfaced. The description only conveys the general domain.

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's 'place' presumably maps to a parameter like city, but it never says which of the nine optional parameters to supply. The schema's city description even refers to a 'weather hint' rather than geocoding, adding ambiguity that the description does not resolve.

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's output (latitude and longitude) and data source (Open-Meteo), making it clear this is a geocoding/coordinate lookup and distinguishing it from siblings like weather-hint and timezone. It lacks an explicit verb such as 'Get' or 'Returns', but the noun phrase is specific enough to convey 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?

Usage is only implied: if an agent needs coordinates for a place, geo-hint is the obvious choice. There is no explicit when-to-use guidance, no exclusions, and no mention of alternatives such as weather-hint for weather or timezone for timezone lookups.

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. 'Parse' suggests a read-only operation with no side effects, and the schema descriptions clarify that unrelated fields are discarded. However, it does not disclose invalid-URL behavior or the exact return format.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to defining what the tool does.

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

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

The core function is clear, and the schema is detailed, but without an output schema or annotations, the return shape and error behavior are left implied. For a tool with many parameters, an explicit note that only 'url' is used would improve completeness.

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

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

Schema description coverage is 100%, so the schema itself documents each parameter. The tool description adds no additional parameter-level meaning; the schema already indicates which fields are discarded.

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

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

The description uses a specific verb and resource: 'Parse owner and repo from a GitHub URL.' This clearly defines the tool's core function and differentiates it 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 intended use is implied: call this tool when a GitHub URL needs to be converted into owner and repo components. However, the description does not explicitly state when not to use it or name alternatives like normalize-url for general URL handling.

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 transparency burden. It does disclose the key output behavior (titles are discarded, only a count is produced) and implies a read-only live fetch. But it does not state that the nine optional inputs are effectively ignored, nor what the return shape or failure behavior 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 extremely concise and front-loaded, with no filler. The staccato 'Titles discarded' is efficient, though slightly ambiguous about whether it refers to HN titles, feed titles, or the return value; a phrase like 'returns only the count' would be clearer.

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

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

For such a simple tool the description is largely adequate: 'Count' implies a numeric result and 'Titles discarded' describes the limited output. However, with no annotations and no output schema, it would benefit from explicitly stating that no arguments are needed (or are ignored) and that the result is an integer count.

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%: all nine parameters have descriptions, so the baseline is 3. The tool description itself adds no parameter-level semantics; it only reinforces that titles are not returned.

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 ('current Hacker News front-page stories'), and the caveat 'Titles discarded' clarifies that the result is a plain count, not story details. This is distinct from the sibling validation, fetch, and 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 declarative phrasing implies use when a count of the current HN front page is needed, and 'Titles discarded' warns against using it when titles are requested. However, it never names a sibling alternative or gives explicit when-not-to-use conditions beyond that title limitation.

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 disclosing behavior. It only describes content, not whether the tool is read-only, returns a static list, ignores parameters, or has any side effects. The schema's notes about parameters being 'discarded' or 'checked' are not reflected in the description, leaving behavioral expectations unclear.

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 or repetition. It is appropriately concise, even though its brevity contributes to the lack of contextual completeness.

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

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

The tool has nine optional parameters, no output schema, and no annotations. A one-clause description cannot tell an agent what the tool returns, which parameters are meaningful, or why a timezone-name tool accepts URLs, city names, JSON, and file paths. This is well below a minimally viable definition.

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

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

Schema description coverage is 100%, and each parameter already has its own explicit description in the input schema, so the baseline applies. However, the tool description itself adds no guidance about which parameters matter or how they map to IANA timezone names, which is a notable gap given the apparent mismatch between the description and the parameters.

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

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

The description names a resource ('IANA timezone names') and a use case ('clock calls'), but it is a noun phrase rather than a clear operation and does not say whether the tool returns, lists, or validates zones. It also fails to distinguish this tool from siblings like timezone or utc-time, and the nine input parameters appear disconnected from the stated 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?

The phrase 'for clock calls' gives only a vague context for when to use the tool. There is no guidance about when to prefer this over timezone/utc-time, no exclusions, and no mention of how the input parameters relate to the intended use.

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 only discloses that the resource is public and that output is limited to group counts. It does not cover error behavior, what the 'group counts' look like, or which parameters are used/discarded.

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

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

The description is a single, front-loaded sentence with no filler. It is concise, though it omits important invocation details that other dimensions penalize.

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

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

Given 9 parameters, no output schema, and no annotations, this brief description is not complete enough. It fails to say which parameter selects the robots.txt source, what a successful result contains, or how failures are surfaced.

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 though the description adds no parameter mapping. However, the schema descriptions are generic (e.g., 'HTTPS URL to normalize or cite') and do not clearly identify which parameter is the robots.txt URL, so the description misses a chance to resolve that ambiguity.

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

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

The description states a clear action ('Fetch a public robots.txt') and a specific output ('return group counts only'), so an agent understands the core purpose. It does not explicitly name sibling tools, but the robots.txt focus is distinct enough from web-fetch/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 siblings like web-fetch, fetch-status, or normalize-url, and no alternatives or exclusions are mentioned. The only implied use case is needing robots.txt group counts.

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

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

With no annotations, the description carries the full burden, but the only behavioral disclosure is 'Key discarded.' It does not state whether the operation is read-only, what it returns, or what validation rules define a valid Jira issue key. The discard note is useful but insufficient for safe tool 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 two short sentences with the primary action front-loaded. There is no filler or redundancy; every word earns its place, even though the content is incomplete 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?

The definition is missing essential context: which parameter is the key, what the expected Jira key format is, what the return value means, and whether any input is required. With no annotations and no output schema, the description leaves an agent unable to call the tool correctly 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 tool-level description never identifies which of the nine schema parameters should hold the Jira issue key, and the parameter descriptions are unrelated ('url', 'city', 'feed', 'json', 'query', etc.). Although schema coverage is 100%, the descriptions actively mislead an agent about how to call this tool. This is a fundamental parameter-semantics failure.

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 a Jira issue key shape.' This clearly distinguishes the tool from sibling shape-checkers like domain-shape and github-repo-shape. The 'Key discarded' fragment is odd but 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?

No guidance is given about when to prefer this tool over alternatives or what kinds of refs/keys are appropriate. There is no mention of exclusions, prerequisites, or comparison to sibling shape-validation tools. The agent must infer usage from the name alone.

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

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

Without annotations, the description carries the behavioral burden. It helpfully discloses that the body is discarded, signaling a lightweight status-only response, but it does not disclose redirect handling, failure behavior, or that only the url parameter is relevant while other schema parameters 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?

The description is two short sentences with the main purpose front-loaded and no filler. 'Body discarded' is a meaningful second sentence that earns its place.

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

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

The tool has no annotations and no output schema, yet the description is extremely sparse relative to the nine-parameter schema and many similar siblings. It fails to say which parameter to populate, what the response format is (beyond status), and how it differs from generic HTTP status tools.

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

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

Schema coverage is 100%, so the baseline is 3, but the tool description adds no mapping from its stated purpose to a parameter. With nine optional parameters, an agent cannot tell that url is the relevant input; several schema descriptions (city, feed, json, query) are unrelated to the tool's stated purpose.

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

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

The description names a specific operation, returning an HTTP status, and a specific resource type, a public library docs URL. It is not a tautology and implies a distinction from generic HTTP tools, though it does not use an explicit verb like 'returns' and 'public library docs' is somewhat 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 usage guidance is given. The description does not mention when to choose this over siblings such as fetch-status, web-fetch, or browser-url-ok, and it gives no exclusions or prerequisites for the docs URL.

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

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

With no annotations, the description carries the behavioral burden. It discloses a key behavioral trait—values are discarded—which prevents an agent from expecting value preservation. It does not specify return format or nested-key behavior, but for a simple count tool this is mostly sufficient.

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, focused sentences with no filler. The core behavior and the important value-discarding caveat are stated directly 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?

The tool is simple and the schema is well documented, but there is no output schema and the description does not explicitly state that a numeric count is returned or how nested keys are handled. The optional-parameter schema partially compensates for the ambiguity, but the description alone 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 input schema already documents all 9 parameters with 100% coverage, so the baseline is 3. The description adds a global 'values discarded' rule but gives no parameter-specific explanation beyond what the schema already provides.

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

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

The description clearly states a specific operation—count keys—and the resource, a JSON object. 'Values discarded' also differentiates it from value-returning or validation tools, though it does not explicitly name or contrast a sibling.

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: use when you need a key count and do not need the values. However, there is no explicit when/when-not guidance or mention of alternatives among the many 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 carries the disclosure burden. It clearly says output comprises origin, host, and path and that query and fragment are dropped, which implies a pure parse. It does not mention invalid-URL behavior, protocol restrictions, or whether any network access occurs, leaving some gaps.

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

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

Two sentences, zero filler, purpose front-loaded. Both sentences earn their place by defining output and exclusions.

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 pure URL-normalization function, the core contract is stated: returned components and dropped parts. But the tool exposes nine optional parameters and no output schema, so the description does not fully disambiguate which parameters are relevant or what happens on malformed input.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds the fact that query and fragment are dropped from the URL input, but it does not explain how the other eight optional parameters relate to normalization; the schema descriptions already label them.

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

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

The description names a specific verb and resource: return origin, host, and path for a URL. It also states the key exclusion that query and fragment are dropped, which makes the tool's purpose concrete and distinguishable from URL-check or shape siblings.

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

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

There is an implied usage: call this when you need URL components without query or fragment. However, the description never says when not to use it or names an alternative from the sibling list, such as domain-shape or figma-url-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?

With no annotations, the description carries the full disclosure burden. It only reveals that no browser is launched, omitting whether a network request is made, what exactly is checked, and how the many other parameters are handled. The schema's 'discarded after the shape check' language hints at a different behavior than 'can be opened,' adding confusion.

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, with the key behavioral distinction ('No browser is launched') placed immediately after the purpose. It earns its place without repetition, though it is terse enough to sacrifice important context.

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

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

For a tool with no annotations, a large parameter set, and no output schema, this description is incomplete. An agent cannot determine the return value, required inputs, or the precise semantics of an 'ok' result. It also fails to distinguish itself from the many sibling URL/network tools beyond the 'no browser' note.

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 provides descriptions for all parameters, so schema coverage is high. The description adds little beyond singling out the URL, and it does not clarify which of the many parameters are relevant or required, nor that most are discarded. This is consistent with the baseline 3 for high schema coverage.

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

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

The description states a clear verb ('check') and resource ('URL'), and the second sentence explicitly differentiates it from browser-based alternatives by noting 'No browser is launched.' However, 'can be opened' is ambiguous—it could mean shape validation, network reachability, or rendering—so the purpose is clear but not fully 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 explicit guidance on when to use this tool versus alternatives. The 'No browser is launched' clause is a negative constraint but does not tell the agent when to prefer this over siblings like browser-url-ok, fetch-status, or web-fetch. Usage context must be inferred.

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. 'Query discarded' usefully signals that the input is not persisted and the operation has no lasting effect. However, it does not clarify whether the other eight optional parameters are ignored or how they interact with the count, nor what the function returns.

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

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

Two short sentences with no filler; the core action is front-loaded and the disposal note adds useful behavioral context without unnecessary words.

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

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

The tool has nine optional parameters and no output schema, yet the description does not name the primary input parameter, clarify that the unrelated fields can be omitted, or describe the return value. Some schema parameter descriptions, such as url 'to normalize or cite', could mislead an agent into thinking they affect this tool's behavior.

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

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

Schema description coverage is 100%, so the schema already documents each parameter, including that query is 'discarded after the length check.' The description adds no parameter-level meaning beyond this, so the baseline of 3 is appropriate.

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

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

The description states a specific action and resource: 'Count characters in a search query', which goes beyond the tool name and is not a tautology. It is clear what the tool does, but it does not distinguish itself from sibling counting/validation tools such as memory-key-count or hn-front-count.

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

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

There is no guidance about when to prefer this tool over alternatives, no when-not-to-use conditions, and no mention of sibling tools. The only implicit hint is that the query is discarded, suggesting it is for length-only checks, but that is not explicit 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says the tool is a 'short catalog', implying a read-only reference, but it does not state whether parameters are ignored, what output format is returned, or why nine unrelated-looking parameters exist. This is a meaningful gap.

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

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

The description is a single concise sentence with no filler. It is front-loaded and easy to parse. It is slightly under-specified, but as a concise summary it is 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?

Despite the tool having 9 parameters, no annotations, and no output schema, the description provides almost no context about invocation, return value, or what inputs matter. A one-line noun phrase is insufficient for an agent to confidently call this tool, especially given the confusing parameter names and descriptions.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description adds no parameter information. However, the parameter descriptions in the schema are odd and mostly describe discarding or unrelated actions, which does not help an agent understand how to query the catalog. Still, the description itself does not need to repeat schema-covered details.

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

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

The description clearly identifies the resource (HTTP status codes) and the general nature of the tool (a catalog/reference). It lacks an explicit verb such as 'returns' or 'looks up', but the meaning is not vague or tautological. It does not explicitly distinguish itself from siblings like fetch-status, but the intent is reasonably clear.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention any precondition, use case, or sibling tool to prefer instead. An agent must infer when a 'catalog of common HTTP status codes' would be relevant.

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 burden. It discloses only that the prompt is discarded, but not whether the tool has side effects, whether the nine parameters are truly ignored, what the template looks like, or whether the call is idempotent.

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

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

Two short sentences are front-loaded and avoid fluff, but 'Prompt discarded' is terse to the point of ambiguity and the definition provides no structure for a tool with nine parameters. This is under-specification more than effective conciseness.

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

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

For a tool with no output schema and no annotations, this is thin: it does not explain the template's contents, how to invoke it, or what the optional parameters are for. An agent could call it with zero arguments, but nothing in the description confirms that.

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

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

The input schema already has descriptions for all 9 parameters (100% coverage), so the baseline is 3. The description adds no parameter-level meaning beyond 'Prompt discarded,' and it doesn't clarify how (if at all) the parameters affect the returned template.

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 phrase 'Return a three-step thinking template' names a concrete verb and deliverable, so an agent knows what the tool produces. It does not explicitly position the tool against the sibling validators/checkers, and 'Prompt discarded' adds ambiguity rather than differentiation.

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

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

There is no statement of when to prefer think-steps over any sibling, and no example or condition. The only hint is the tool's name and output, leaving an agent to infer that it is for producing a reasoning template.

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 promises a timezone lookup, yet the input schema contains entirely unrelated parameters like ref, url, city, and json — there is no timezone parameter at all. This makes the description misleading about how the tool actually behaves.

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

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

The description is a single short sentence with no wasted words and is front-loaded with the tool's core output. However, its brevity actually obscures the major mismatch with the input schema, so the structure does not meaningfully aid correct 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?

Given nine parameters, no output schema, and no annotations, the description is radically incomplete. It fails to explain how the timezone is selected, what the response format is, or why the listed parameters are present. An agent has almost no dependable basis for calling this tool correctly.

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

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

Although every parameter has a schema description, none of those descriptions relate to timezone or the stated purpose. The description adds no mapping between the 'named IANA timezone' concept and any parameter, so an agent cannot determine which input to use. This is a severe semantic disconnect.

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 exactly what the tool returns: current time in a named IANA timezone. It is a specific resource and operation, and it can be distinguished from sibling tools like utc-time and iana-zones at a high level. However, it does not name any sibling or explain how the timezone is supplied.

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 utc-time or iana-zones. The description implies a general use case but does not clarify prerequisites, exclusions, or what should be passed in.

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

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

Without annotations, the description carries the full burden of behavioral disclosure, but it only states the output. It fails to mention that the tool discards all inputs after a shape check or that it accepts a variety of parameter types. The schema hints at this, but the description itself is silent, leaving the agent unaware of the 'discard' behavior and the lack of 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 wasted words. It efficiently conveys the core purpose, though it is under-specified given the complex 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?

The tool has no output schema and no annotations, so the description must explain the return format and the purpose of the confusing parameter list. It does neither. An agent cannot know what the timestamp looks like (ISO string, epoch seconds, etc.) or why it might pass a URL, feed, or city name.

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 adds no meaning to the seven input parameters. While the schema provides per-parameter descriptions, they are disconnected from the tool's stated purpose and even suggest contradicting actions (e.g., 'normalize or cite' for url). The agent cannot determine the parameters' actual role or whether to pass them, so the semantics remain unclear.

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

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

The description 'Current UTC timestamp' states the tool's function clearly and distinguishes it from siblings like 'timezone' and 'iana-zones'. However, it uses a noun phrase rather than a verb and does not mention the schema's apparent shape-check aspect.

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 like 'timezone' or 'web-fetch'. The description does not mention the strange input parameters or any constraints, leaving the agent to infer usage from the tool name alone.

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

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

The statement 'The body is discarded' is a useful behavioral disclosure, especially since no annotations are provided. Still, the description does not mention what the tool returns (e.g., boolean, error), whether it performs network access, or how it handles malformed JSON.

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

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

The description is extremely concise and front-loaded: the primary purpose is stated first, and the behavioral note about discarding follows immediately. Every sentence earns its place with no redundancy.

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

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

For a tool with no annotations, no output schema, and nine optional parameters, this description is too thin. It fails to explain the response, connect 'body' to the relevant 'json' parameter, or clarify how this tool fits among the many sibling validation utilities.

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. The description adds no parameter-level meaning beyond the schema and does not clarify how 'body' maps to the 'json' 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 action ('Check whether a body is valid JSON') and resource (JSON body), making the core purpose immediately clear. However, it does not explicitly differentiate itself from sibling validation tools, and 'body' is left somewhat ambiguous since the schema contains no parameter named 'body'.

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 domain-shape, normalize-url, or other validation-oriented siblings. No contexts, exclusions, or prerequisites are provided, so the agent must infer 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?

With no annotations, the description carries the full behavioral disclosure burden. It reveals the external dependency on Open-Meteo, but it does not disclose that the tool relies on the city parameter while the other eight optional schema fields appear unrelated or 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?

The tool is not fully specified: there is no output schema, yet the description does not mention temperature units or response shape. The presence of nine optional parameters in the schema makes the missing guidance about which parameter matters a significant 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 schema already documents all parameters and the baseline is 3. The description adds marginal value by pointing to 'city', but it does not clarify how the other optional parameters should be handled.

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

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

The description clearly states that the tool returns the current temperature for a city and names Open-Meteo as the data source. It is specific enough to convey the core purpose, though it does not explicitly distinguish itself 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?

The intended use case is implied: an agent should use this tool when it needs a city's current temperature. However, there is no explicit guidance about when not to use it or which alternative tool 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 provided, the description carries the burden of behavioral disclosure. It does disclose a meaningful behavior: the HTTP response body is discarded. However, it does not mention redirects, timeouts, error handling, or whether only 'public' URLs are accepted, leaving important behavioral gaps.

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

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

The description is two short sentences, front-loads the core behavior, and contains no filler. It is appropriately concise for a simple intent, though the unusual schema may have warranted additional clarifying 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?

Given a complex seven-parameter schema and no output schema or annotations, the description is too sparse to be complete. It does not explain which parameter to pass, how the result is returned, or how this tool relates to its URL-focused 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?

The schema lists seven parameters, all with descriptions, but those descriptions are largely unrelated to the described tool (e.g., 'City name for a public weather hint', 'JSON text to validate') and the url description says 'normalize or cite' rather than fetch/status. The tool description does not clarify which parameters actually apply to web-fetch, so parameter selection is unreliable.

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

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

The description clearly identifies the resource (a public URL) and the output (HTTP status and content type), and the 'Body discarded' qualifier adds specificity. It does not explicitly differentiate this from sibling tools like fetch-status, so it falls 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 web-fetch instead of fetch-status, browser-url-ok, playwright-url-ok, or other URL-related siblings. The description gives no conditions or exclusions, so an agent has no help choosing between overlapping tools.

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

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

With no annotations, the description carries the full disclosure burden. It adds a useful behavioral note that the title is 'discarded after the call,' implying non-retention, but it does not clarify whether the operation is read-only, network-bound, or what output to expect. The disclosure is helpful but incomplete.

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 second sentence adds a specific behavioral detail without bloat.

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 is unusually broad (12 optional properties) and there is no output schema or annotations. The description fails to tell the agent which parameter to supply (title, optionally lang), that other parameters can be ignored, or what the check returns. This incompleteness creates real risk of misinvocation.

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 12 parameters, including 'title: Wikipedia title to check' and 'lang: Language code for Wikipedia.' The tool description adds no further parameter meaning and does not clarify that other schema fields are likely irrelevant to this tool, so the high schema coverage sets the baseline at 3.

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

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

The description states the specific action and resource: 'Check whether a Wikipedia title exists.' This clearly distinguishes the tool from siblings like browser-url-ok or fetch-status, which target URLs and HTTP statuses rather than Wikipedia titles.

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

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

No guidance is given on when to use this tool versus alternatives. There is no mention of supporting tools like web-fetch or normalize-url, no exclusion conditions, and no context such as 'use this when you only need existence, not page content.'

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