ISO country OM

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

The description adds a notable behavioral detail: 'Task text discarded', which tells the agent not to expect task-specific processing. It also lists return components. However, without annotations, it does not disclose failure modes, authorization needs, or possible pay-per-call cost implications.

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 three short sentences with no filler or redundancy. The main purpose is front-loaded, and the behavioral caveat is placed last without bloating the text.

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

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

The description leaves a significant invocation gap: six unrelated params are present, the schema marks them as discarded, and 'task text' is not a schema param, so it is unclear what to actually pass. There is no output schema, and return values are only summarized, so an agent may not know what to expect or how to call this correctly.

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

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

Schema coverage is 100%, so the parameters are already documented; the description adds no parameter-level meaning. Since the schema descriptions themselves say the params are discarded or validated only for shape, the description does not need to repeat those 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 states a specific action, 'Find', and a specific resource, 'public pay-per-call tool gateway (Monid)', and lists the returned artifacts: CLI setup, how-it-works, skill file, and remote MCP hops. It is clear about the tool's purpose, though it does not explicitly differentiate from sibling tools or explain what 'Monid' is.

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: the agent would select this when it needs the Monid gateway. There is no explicit 'use this instead of X' or 'do not use this when Y' guidance, which is a gap given the large set of sibling validators.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only reveals that no browser is launched. It does not state whether the tool makes an HTTP request, how it defines an openable URL, whether it follows redirects, what status codes count as OK, what it returns, or whether the check has side effects. This is too thin for a networked check 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?

The description is one short sentence that front-loads the core purpose and a key behavioral caveat. There is no filler, repetition, or unnecessary detail.

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

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

The tool has 9 optional parameters, no annotations, no output schema, and several similar sibling tools, yet the description is a single sentence. Missing are the return format, the correct parameter to supply, and operational semantics such as network behavior, timeouts, and acceptable status codes. An agent would struggle to invoke this tool confidently without additional context.

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

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

Schema description coverage is 100%, so the baseline is 3. The schema documents each of the 9 optional parameters individually, and the tool description at least implies that the 'url' parameter is the relevant one. However, the description itself adds no parameter guidance, and several schema descriptions are unrelated to URL checking (city, json, path, zone, query), which creates some ambiguity about which field actually drives this tool.

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

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

The description states a clear action and target: 'Check whether a URL can be opened.' It also adds a distinguishing behavioral note, 'No browser is launched,' which separates it from sibling playwright-url-ok. However, 'can be opened' is left somewhat vague—there is no definition of success criteria—and the wording partially restates the tool name.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no alternative tool is named. The only signal is the negative statement 'No browser is launched,' which hints that this is a lightweight check rather than a rendering test, but it does not tell the agent when to prefer this tool over normalize-url, fetch-status, or playwright-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 present, so the description carries the burden of explaining side effects and return behavior. It only says 'Expression discarded,' which is ambiguous, and it fails to say whether the tool returns a numeric result or nothing.

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

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

The text is short, but the second sentence ('Expression discarded') adds ambiguity rather than value, and the description omits essential invocation details. This is under-specification, not efficient conciseness.

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

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

With nine parameters, no annotations, and no output schema, the description must explain which parameter is the expression and what output to expect; it does neither. The description is far too incomplete to support correct 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?

Although schema descriptions cover 100% of parameters, the tool description introduces 'expression' without mapping it to any schema property. An agent cannot determine how to supply a+b, so the description fails to compensate for the schema's missing arithmetic operand.

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 ('Evaluate a+b style arithmetic'), but it does not match the schema: none of the nine parameters accepts an arithmetic expression, and 'Expression discarded' muddles whether a result is returned. It is closer to a tautology of the name calc-eval than a usable purpose 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?

There is no guidance on when to use this tool, which parameter carries the expression, or which sibling tool is the alternative. The only implication is simple arithmetic, but no explicit context or exclusions are provided.

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

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

The description adds a useful behavioral guarantee: 'Page content is not stored.' With no annotations present, this partially compensates for the lack of safety cues. However, it does not disclose whether a network request is made, whether results are cached, or how the many other input fields are handled.

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

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

The description is two short sentences with no filler. The primary behavior is front-loaded, and the second sentence earns its place by adding a meaningful privacy/storage guarantee.

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 a small description, the tool has 9 parameters, no output schema, no annotations, and many closely related sibling tools. The description lacks selection guidance, output format details, and any explanation of the broader parameter set, making it 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?

The input schema already describes all 9 parameters with 100% coverage, so the baseline is 3. The description adds little beyond mentioning a 'URL,' and it does not explain the purpose of the other parameters like ref, city, feed, json, or path. It also uses 'host' as both an output term and an input parameter, which could create mild 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 operation: 'Return host, scheme, and HTTP status for a URL.' This identifies the verb, resource, and expected outputs. However, it does not differentiate this tool from siblings like normalize-url or fetch-status that likely overlap in behavior.

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

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

The description provides no guidance on when to use this tool versus alternatives such as fetch-status, normalize-url, or browser-url-ok. It neither states conditions for use nor names exclusions or 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 the behavioral disclosure burden. It does add one useful privacy guarantee ('No identifiers are retained'), which matches the schema's 'discarded after the check' notes. But it does not disclose what the classification output looks like, whether any external requests are made, what errors can occur, or what side effects exist beyond not retaining identifiers.

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: one sentence, no filler, and the core action is front-loaded. However, for a tool with 9 parameters, no output schema, and a large sibling list, this is under-specification rather than appropriately sized 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 the tool's complexity, all-optional parameters, absence of an output schema, and lack of annotations, the description is not complete enough. An agent cannot determine which parameter to populate, what classification labels to expect, or what the tool returns. The detailed input schema partially compensates, but the overall tool contract remains unclear.

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

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

Schema description coverage is 100%, so every parameter already has its own semantic explanation, e.g., 'Git ref name; discarded after the shape check.' The tool description adds no per-parameter meaning, but it does not need to because the schema fully documents the parameters. Baseline 3 applies.

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

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

The description names a clear action ('Show how this request is classified') and a general object, so it is not a pure tautology. However, it never explains what classification scheme is used, what labels/categories are produced, or how this relates to the tool name 'compatibility.' It also does not distinguish the tool from sibling classifiers/shape tools like domain-shape, figma-url-shape, or validate-json.

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

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

There is no sentence saying when this tool should be used instead of the many sibling tools. The description gives no use cases, exclusions, or routing hints; the only contextual signal comes from the input schema rather than from the description itself.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose that no WHOIS or ownership data will be fetched, which is useful. But it does not describe the return format, behavior on invalid hostnames, or what happens when non-host parameters such as url, city, json, or zone are supplied. Given the broad optional schema, this transparency gap is significant.

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 or repetition. The core behavior and a key scoping constraint are front-loaded, and every word contributes to the tool's 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?

The tool has no output schema and no annotations, yet it exposes nine optional parameters and sits among many related sibling tools. A one-line description of hostname splitting is not enough for an agent to invoke it reliably, because it omits the return shape, how to select the right parameter, and when to prefer this tool over similar ones.

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

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

The input schema already documents all nine parameters, so the baseline is 3. The description adds essentially no parameter-level meaning beyond loosely aligning 'hostname' with the `host` property. It doesn't indicate whether `host` is the relevant argument or whether the other fields are alternatives or 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 operation ('split') and resource ('hostname'), and specifies the result ('labels'). The qualifier 'without WHOIS or ownership data' distinguishes it from ownership lookups. It loses a point because the input schema exposes nine unrelated optional parameters, and the description doesn't clarify how they fit with the stated hostname-splitting 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 description implies the tool is for pure hostname label decomposition and explicitly rules out WHOIS or ownership data. However, it names no sibling alternatives or conditions for choosing this tool over related tools like normalize-url, browser-url-ok, or web-fetch. It also doesn't say which input parameter should be populated.

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 discloses that the call is a HEAD request (read-only, no body) and that the response is limited to status, which is meaningful. It does not mention redirects or error behavior, but the core behavior is transparent enough for a simple fetch-status 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?

One short sentence front-loads the verb and directly states the input and output. No filler or repeated schema information.

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

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

For a nine-parameter tool with no annotations and no output schema, a single sentence leaves gaps: it does not explain why the other eight parameters exist, why none are required, or how status/errors are returned. However, the core invocation (URL in, status out) is clear enough for basic use.

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

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

All nine parameters already have descriptions in the schema, so the baseline applies; the tool description adds no parameter-level meaning. It does clarify that the URL is the target of the HEAD, which helps agents pick `url`, but the schema's own `url` description ('normalize or cite') is slightly inconsistent with status checking.

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 ('HEAD'), a specific resource ('a public URL'), and a narrow output ('status only'), so an agent can tell what it does. It loses one point because the input schema exposes nine unrelated optional parameters, so the described purpose does not fully reconcile with 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?

The phrase 'status only' implies a lightweight use case and distinguishes it from full-page fetches, but the description never names alternatives or states when not to use it. With siblings like web-fetch, browser-url-ok, and normalize-url present, explicit routing would help; without it, the guidance is only implied.

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 disclosing behavior, but it only states 'Path discarded.' It does not say whether the tool is read-only, whether it performs network access, what it returns, or how it handles invalid URLs. The discarded-path note is a small positive, but it is ambiguous.

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

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

The description is very short and the core purpose is front-loaded in the first sentence. 'Path discarded' is efficient but slightly elliptical, so it is not quite a 5.

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

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

Given no output schema, no annotations, and a 9-parameter input, the two-phrase description is incomplete. An agent would not know what a successful parse returns, whether this is validation or extraction, or which parameters beyond url/path 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?

The schema already documents all 9 parameters, so the baseline is 3. The description adds value by identifying the relevant input as a Figma file URL (whereas the schema's 'url' description is generic) and confirming the path is ignored. It does not explicitly name the 'url' parameter, but that is inferable.

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 ('Parse') and a specific resource ('a Figma file URL'), which clearly distinguishes it from sibling URL tools like normalize-url or web-fetch. The additional 'Path discarded' note, while terse, 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?

The description implies a use case: when an agent needs to parse a Figma file URL. However, it gives no explicit guidance about when not to use it, no prerequisites, and no comparison to sibling tools such as browser-url-ok or normalize-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; 'No disk access' is a clear and valuable guarantee that the check is purely syntactic and non-destructive. 'Looks safe' also signals heuristic validation rather than filesystem verification. It does not detail the exact return value or error cases, but the yes/no nature is strongly implied.

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

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

Two short, front-loaded sentences with no filler. Both statements—the action and the no-disk-access caveat—earn their 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?

Despite having 9 optional parameters and no output schema or annotations, the description is only one line of functional detail. An agent is not told which parameter(s) to pass, what the response looks like, or what 'safe' means; the no-disk-access note helps but does not make the tool complete to invoke correctly.

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

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

Schema description coverage is 100%, so the schema already documents every parameter. The description adds no parameter-level meaning beyond naming 'path'; it does not clarify which of the 9 optional parameters should be supplied or whether they are mutually exclusive, 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 and resource: 'Check whether a path looks safe' and adds a key constraint, 'No disk access.' This clearly identifies it as a file-path validator and distinguishes it from URL/JSON/title checkers among the siblings. It stops short of a 5 because it does not explicitly differentiate from sibling tools and the input schema exposes many unrelated optional parameters.

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

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

There is no guidance about when to use this tool versus alternatives such as normalize-url, validate-json, or browser-url-ok. 'No disk access' hints at a safe validation context, but no explicit when/when-not conditions or alternatives are given.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only mentions Open-Meteo, implying an external lookup, but does not describe return format, failure behavior, network dependency, or that many schema fields are discarded. The schema's 'discarded after...' notes are not reflected in the description.

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

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

The description is a single concise sentence with no filler, which is efficient. However, for a complex tool with 9 optional parameters, no annotations, and no output schema, it is too minimal to be considered well-structured; the brevity comes at the cost of crucial 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?

Given the tool's complexity, one sentence is inadequate. The description does not explain which parameter represents the place, what the returned coordinates look like, how failures are handled, or how this tool relates to the many sibling hint/check tools. The agent would struggle to invoke it correctly.

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

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

The input schema already documents all 9 parameters with 100% coverage, so the description is not required to restate them. It adds the geocoding intent (place -> coordinates via Open-Meteo), but it does not map the description to a specific parameter such as 'city' or reconcile the unrelated-looking schema fields.

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

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

The description clearly identifies the core purpose: returning latitude and longitude for a place via Open-Meteo. It is not a tautology and informs the agent what kind of result to expect, though it does not explicitly distinguish geo-hint from related sibling tools like weather-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 description gives no guidance about when to use this tool versus alternatives, nor does it mention conditions, exclusions, or prerequisites. An agent is left to infer that a 'place' must be supplied, but the schema has 9 optional parameters and no indication of which one is the place.

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 only says 'Parse' and does not mention that several parameters are discarded after validation, that behavior may depend on which parameter is supplied, or what happens on invalid input. The schema's 'discarded' notes are not reflected in the description.

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

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

The description is a single front-loaded sentence with no filler, which is efficient. However, it is so terse relative to the broad schema that concision comes at the cost of needed operational detail.

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

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

A 9-parameter tool with no output schema and no annotations needs far more than a one-line purpose statement. The description does not indicate which parameter drives the GitHub parse, what the return shape is, or how the other params relate to the tool.

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

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

The input schema has 100% parameter description coverage, so the baseline is 3. The description adds only the idea that the URL is a GitHub URL and that owner/repo are the parsed result, but it does not clarify which of the 9 parameters should be used for that 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 uses a specific verb ('Parse') and a concrete resource ('owner and repo from a GitHub URL'), and the GitHub mention differentiates it from sibling shape tools like figma-url-shape and jira-key-shape. It loses a point because the input schema exposes many unrelated parameters, so the stated scope is clearer than the tool's actual surface.

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

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

No explicit when-to-use guidance, exclusions, or named alternatives are given. The agent must infer from the tool name and sibling list that this is meant for GitHub URLs, which is fragile given the 9-parameter schema.

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 and no output schema, the description carries the transparency burden. It does disclose that titles are discarded and that the result is a count of current stories, but it does not state whether the tool performs a network fetch, what a failure looks like, or the exact return shape. This is adequate for a simple read-only count but leaves some behavioral details implicit.

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 exceptionally concise and front-loaded: the first sentence states the core operation and scope, and the second sentence clarifies an important limitation. Every word earns its place with no repetition or filler.

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

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

The description is complete enough for a zero-required-parameter tool, since 'Count' implies an integer result and 'Titles discarded' clarifies the output scope. However, given the large optional parameter list and the absence of an output schema or annotations, an agent could still be uncertain whether any parameter is required and what runtime failures might occur.

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 meaningful parameter guidance beyond the schema, and notably does not clarify which of the nine optional parameters, if any, are actually relevant to the count operation. This is acceptable only because the schema already documents each 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 clearly states a specific verb ('Count') and a specific resource ('current Hacker News front-page stories'), and clarifies that titles are not returned. It does not explicitly differentiate from sibling tools like web-fetch or normalize-url, but the HN-specific scope makes the purpose 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?

The description implies the tool is for obtaining a count of current HN front-page stories and that title content is not needed. However, it gives no explicit guidance on when to prefer this over alternative tools or when not to use it, leaving usage to inference.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses no behavior: no return format, no side effects, no statement of whether the nine input parameters are used, and no indication of read-only or safety characteristics.

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 definition is brief and front-loaded, but it is under-specified rather than concisely complete. A single non-sentential fragment cannot convey the tool's action or interface, and it fails to earn its place as a usable tool 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?

The fragment at least identifies the domain and an intended use case, so it is not entirely missing. However, with nine optional parameters, no annotations, and no output schema, it does not explain what the tool returns or how the parameters relate to the stated purpose.

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, which sets the baseline at 3. The description adds no parameter meaning and even creates confusion because parameters like ref, url, city, feed, host, json, and path are unrelated to timezone names.

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, 'Common IANA timezone names for clock calls,' with no verb stating whether the tool returns, lists, validates, or selects zones. It largely restates the tool name 'iana-zones' and only adds the vague context 'for clock calls.'

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' implies a use case, and 'common' hints at scope, suggesting this tool provides a curated list for clock/time utilities. However, it names no sibling alternatives and gives no explicit conditions 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. It honestly discloses that the tool performs an external fetch and returns only counts, but it does not mention failure behavior, rate limits, or how missing/invalid robots.txt files 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?

One front-loaded sentence with no filler. The action, resource, and output shape are all conveyed 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?

Given the large ambiguous parameter set, no annotations, and no output schema, a single sentence is insufficient. The description does not define what 'group counts' looks like, which input actually matters, or how errors 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 acceptable, and the schema at least labels each parameter. However, the description adds no guidance on whether the robots.txt is fetched from the 'host' or the 'url' parameter, leaving nine optional parameters ambiguous in a way the description should 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 a specific action (fetch a public robots.txt) and a precise return scope (group counts only). This clearly separates it from sibling fetch-oriented tools like web-fetch and fetch-status.

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

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

The description implies the tool is for retrieving robots.txt group-count summaries, but it does not explicitly say when to prefer it over alternatives or when not to use it. Usage context is present only by inference.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. 'Key discarded' is a useful disclosure that the input is not retained, but the description does not say whether the check is syntactic only, what happens on invalid shapes, or whether a network call is involved.

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

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

The description is two short sentences with no wasted words, and the main action is front-loaded. 'Key discarded' is an efficient additional behavioral note.

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

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

For a tool with nine parameters, no annotations, and no output schema, the description is radically incomplete. It does not identify the required parameter, describe the expected return value, or explain edge cases, so an agent cannot reliably invoke it.

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

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

Schema coverage is 100%, so each parameter has a description, but those descriptions describe unrelated concepts such as Git refs, URLs, timezone names, and search text. The description adds no parameter meaning, and critically, none of the parameters is identified as the Jira issue key, leaving the agent unable to select the correct 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, checking a Jira issue key shape, and the 'Key discarded' note adds a privacy-relevant detail. However, the input schema exposes nine generic string parameters with no field that obviously holds a Jira key, so the stated purpose cannot be mapped to any input. This mismatch makes the purpose misleading rather than helpful.

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

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

No guidance is given about when to use this tool versus sibling shape-checkers like github-repo-shape or domain-shape. The description implies it should be used for Jira issue keys, but it does not explain when not to use it or which alternative to prefer.

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 a meaningful behavior—'Body discarded'—and implies a read-only network status check. However, it does not address redirect handling, timeouts, authentication, failure behavior, or how the many optional schema fields affect the 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?

The description is two short sentences with the core purpose front-loaded and no filler. The second sentence earns its place by adding the body-discard 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 tool with 9 optional parameters, no annotations, and no output schema, this description is too thin. It does not state which parameter is primary, whether parameters are mutually exclusive, what the exact return format is beyond 'HTTP status', or why unrelated fields like city, feed, and json are present. An agent would have difficulty invoking the tool reliably.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds only the hint that `url` should be a public library docs URL, but it provides no guidance on ref, city, feed, host, json, path, zone, or query, and it slightly conflicts with the schema's generic 'HTTPS URL to normalize or cite' wording.

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—returning HTTP status—for a specific resource type, a public library docs URL, and adds the behavioral note that the body is discarded. It is not a tautology and is more focused than a generic fetch-status or web-fetch, though it never defines what qualifies as a 'public library docs URL' or compares itself to siblings.

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

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

The description implies the intended use case: retrieve the HTTP status of a public library docs URL. It provides basic context but does not explicitly state when to prefer this tool over fetch-status, browser-url-ok, or web-fetch, and it gives no exclusions or alternative-selection criteria.

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

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

No annotations are present, so the description carries full behavioral burden. It usefully discloses that values are discarded, but it does not state the return type, whether nested keys are counted, how invalid JSON is handled, or whether input is mutated. The schema's 'json' parameter description even says 'discarded after the check', which undercuts the counting 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 two short sentences with the action front-loaded, and 'Values discarded' adds meaningful behavioral context without filler. It is concise and readable, though the brevity omits essential invocation details.

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

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

With no annotations, no output schema, and a confusing multi-parameter input schema, the description should identify which argument holds the JSON object and what the tool returns. It does neither, leaving an agent unable to reliably invoke the tool. The core operation and one behavioral hint are present, so it is not wholly inadequate, but significant gaps remain.

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 all parameters, but most (ref, url, city, feed, host, path) are unrelated to the tool's stated purpose and are described as discarded or used by other kinds of checks. The only plausible JSON-related parameter, json, is described as 'JSON text to validate; discarded after the check', not as the object whose keys are counted. The tool description does not clarify which parameter supplies the JSON object.

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 action ('Count') and resource ('keys in a JSON object'), and 'Values discarded' indicates it is not a value-mutating or validating tool. It does not explicitly differentiate it from sibling tools like validate-json or hn-front-count, but the core purpose is recognizable.

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

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

There is no guidance about when to use this tool versus alternatives such as validate-json or domain-shape. No prerequisites, exclusions, or sibling comparisons are provided, so an agent must infer usage solely from the short imperative.

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

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

With no annotations, the description carries the behavioral disclosure burden. It does disclose one meaningful behavior: query and fragment are dropped from the URL. However, it does not cover edge cases, error behavior, normalization details, or what happens when the URL is invalid, and the presence of many unrelated optional parameters is unexplained.

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 efficient, but for a tool with a 9-parameter schema and no annotations, the brevity leaves important context unstated, so it is not fully appropriately sized.

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

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

The description is too sparse relative to the context: nine optional parameters, no output schema, no annotations, and many sibling tools. It does not explain which parameter is the primary input, what the other parameters mean, what the return format is, or how this tool relates to URL-checking siblings.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds mild semantic value by clarifying that URL query and fragment components are removed, but it does not clarify the roles of the other eight parameters. The word 'query' is even used in a different sense than the schema's 'query' parameter, which could cause confusion.

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: 'Return origin, host, and path for a URL.' It also states a clear behavior, dropping query and fragment, which makes the tool's basic purpose understandable. It does not explicitly distinguish itself from sibling tools, but the output shape is unique enough to infer a distinct role.

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, web-fetch, or citation. The description only states what the tool does, not the conditions that should lead an agent to select it, and it does not mention any exclusions or prerequisites.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure. It reveals that no browser is launched, which is a useful distinguishing trait, but it omits whether a network request is made, whether the operation is read-only, or what the result actually indicates about the URL.

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

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

The description is two short sentences with the main verb and resource front-loaded. The second sentence adds a critical exclusion without any wasted words. It is appropriately sized for the complexity.

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 a small tool description, the tool has seven parameters with mixed relevance, no output schema, and no description of return values. An agent would not understand why unrelated parameters are accepted or what the expected response is. The minimal description leaves significant gaps in invoking the tool correctly.

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

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

All seven parameters have individual descriptions in the input schema, so the schema already provides comprehensive coverage. The tool description adds no extra meaning about how parameters relate to the URL check or why unrelated-looking fields like city, feed, and json are accepted.

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 whether a URL can be opened) and distinguishes itself from browser-based tools with 'No browser is launched.' It does not explicitly name sibling tools or clarify what 'can be opened' means in terms of HTTP status or reachability, which leaves some ambiguity.

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

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

The description gives no explicit guidance on when to use this tool over alternatives like browser-url-ok, fetch-status, or web-fetch. The phrase 'No browser is launched' implies a lightweight use case but stops short of explaining trade-offs or exclusion criteria.

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

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

There are no annotations, so the description must carry the behavioral burden. It does disclose that the query is discarded, which is a meaningful side-effect statement, but it does not disclose return format, whether a network call is made, or behavior when no query parameter is provided.

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

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

The description is two short sentences with no filler. The core action is front-loaded, and the behavioral note 'Query discarded' is concise and relevant.

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 omits the return value type and does not state which of the nine optional parameters is the search query. The schema compensates for parameter documentation, but the tool's call semantics are not fully spelled out 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 does not add meaningful parameter semantics beyond what the schema already says; it refers to 'a search query' but does not explicitly name the 'query' parameter, and the schema already documents the discard behavior.

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

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

The description states a specific verb and resource: 'Count characters in a search query.' It clearly distinguishes the tool from siblings like normalize-url or validate-json by focusing on search-query length, and the additional sentence 'Query discarded' clarifies that the query is not retained.

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 such as memory-key-count or calc-eval. It only states what the tool does and that the query is discarded, leaving the agent to infer appropriate use cases.

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

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

No annotations are present, so the description must carry the full behavioral disclosure burden. It does not state whether the result is returned locally, whether inputs are discarded, or whether any network or side effect occurs; it only says there is a catalog.

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, but it is under-specified to the point of being a stub. Conciseness is not valuable when the sentence does not communicate tool operation, return behavior, or parameter relevance.

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 output schema, and many status/URL-related siblings, the description omits the return value, how parameters affect the catalog, and when this tool should be chosen. This is far from enough context for correct 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 even without parameter details in the tool description. However, the description adds no meaning connecting the heterogeneous parameters to the status-code catalog, and the schema notes only per-parameter discard behavior.

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

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

Description largely restates the name: 'Short catalog of common HTTP status codes.' It identifies the subject matter but gives no operation, and the nine unrelated-looking parameters (url, city, json, path, etc.) make it unclear what invoking this tool actually does.

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

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

No guidance is provided about when to use status-catalog instead of siblings like fetch-status or web-fetch. The description does not name alternatives, exclusions, or a concrete selection condition.

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

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

With no annotations, the description carries the full burden. It does disclose a key behavior: the prompt is discarded, so the returned template is not customized. However, it does not explain what the three-step template actually contains, whether the optional parameters are honored, or what side effects, if any, exist. This is a moderate level of transparency.

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

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

Two short sentences with the main action front-loaded. There is no fluff. The phrase 'Prompt discarded' is terse but earns its place by warning that input will be ignored. It could be slightly more explicit, but it is well within appropriate conciseness.

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

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

Despite a rich input schema and no output schema or annotations, the description is minimal. It does not explain what the three-step template is, how the optional parameters relate to it, or what the caller should expect in return. An agent has enough to identify the tool but not enough to confidently predict the output or side effects.

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

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

Schema coverage is 100%, and each optional parameter has a useful description (e.g., 'discarded after the shape check'). The tool description itself adds little beyond 'Prompt discarded,' but the schema already documents the parameters. The baseline score of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Return a three-step thinking template.' It clearly distinguishes itself from sibling validation/fetch tools. 'Prompt discarded' adds the important clarification that this is not a processing tool, though 'thinking template' remains somewhat abstract.

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 call this tool rather than a sibling. The phrase 'Prompt discarded' implies the tool is appropriate for a fixed template, but it does not state expected use cases, exclusions, or alternatives. An agent must infer the selection criteria.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Current time' implies a read-only operation, but the description does not disclose the return format, how invalid timezone names are handled, or that the schema contains nine mostly unrelated parameters with no explicit timezone field. The description is not contradictory, but it is largely opaque.

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

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

The description is a single sentence with no filler, and the core action is front-loaded. It is efficient and easy to scan, though it may be too terse to provide necessary operational context. Still, it earns a strong score on conciseness.

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

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

With no annotations, no output schema, and nine optional parameters, this one-line description is completely inadequate. It omits how to specify the timezone, what the response contains, and how the unrelated parameters relate to the tool. An agent cannot reliably invoke this tool correctly based on the description alone.

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

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

The schema covers all nine parameters with individual descriptions, which would normally support a baseline of 3. However, the description's key concept—'named IANA timezone'—has no corresponding schema property; the parameters are git refs, URLs, cities, feeds, hosts, JSON, and paths. The description therefore gives an agent no way to determine which parameter supplies the timezone.

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 explicit operation—retrieve the current time—and an explicit resource scope, 'named IANA timezone'. This distinguishes it from sibling tools like utc-time and iana-zones even though it does not name them. It is not a tautology and communicates the core purpose clearly.

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 the related utc-time or iana-zones tools. There are no alternative tools mentioned, no exclusions, and no context such as 'use this when you need a specific timezone rather than UTC.' Usage is only weakly implied by the phrase 'named IANA timezone.'

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 implies a read-only operation, but it does not disclose that all seven parameters are discarded, nor does it specify the return format (Unix timestamp vs. ISO string). These are important behavioral details for an agent.

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 three words and contains no filler. It is front-loaded and appropriately sized for a simple utility, even though additional guidance could improve other dimensions.

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

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

Given no output schema, no annotations, and a non-obvious seven-parameter input list, the description is too terse. It does not state the exact return representation or explicitly clarify that parameters do not affect the result. The schema partially compensates, but the overall definition is incomplete.

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

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

The schema itself provides detailed descriptions for all parameters, including notes on discarding and no disk access, so schema coverage is high and the baseline is 3. The tool description adds no parameter-related meaning, but the schema already does the necessary work.

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 resource and result: a current UTC timestamp. It is unambiguous and distinguishable from sibling tools like timezone or iana-zones. It lacks an explicit verb, but the meaning is specific enough for an agent to understand the tool's 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 explicit guidance about when to use this tool versus alternatives like timezone. The word 'current' implies a clock lookup, but no conditions, exclusions, or alternative tool references are provided.

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

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

No annotations exist, so the description must carry the behavioral burden. It does disclose one non-obvious trait: the body is discarded after the check. But it does not say what the tool returns (boolean, error messages) or how validation failures are surfaced, which is essential for an agent using it.

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

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

Two short sentences with no filler and the core action front-loaded. The phrase 'body is discarded' earns its place as a behavioral disclosure, though naming the `json` parameter would improve clarity.

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

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

The tool has no output schema and no annotations, so the description must explain return/results and input expectation on its own. It mentions a body but the input schema has nine optional string parameters, and it is unclear how to supply the JSON to validate.

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; each parameter has a description. The tool description itself adds no parameter-level meaning and never maps 'body' to the `json` property, though the schema's `json` description compensates somewhat.

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 check verb and target resource ('valid JSON'), which distinguishes it from sibling shape validators. However, it refers to 'a body' without tying it to the actual `json` parameter, leaving some ambiguity about what exactly is validated.

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?

Provides no guidance on when to choose validate-json over siblings, nor any conditions or exclusions. There is no mention of alternatives or use cases beyond the one-line task.

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 conveys an external Open-Meteo lookup and a read-only data retrieval, but it does not clarify that parameters other than city are ignored, nor does it mention API constraints or the exact return format. It is adequate but thin.

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 names the action, resource, and provider with no filler. It is easy to parse and every word contributes to understanding.

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 weather lookup, the description plus fully covered schema is mostly workable. However, the absence of annotations, output schema, and usage guidance leaves gaps around return format, parameter roles, and when to prefer this over neighboring tools. It is minimally complete but not robust.

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 and which ones are discarded. The tool description adds no parameter-level meaning beyond identifying 'city' as the relevant input, which meets the baseline 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 clearly states a specific function: retrieving the current temperature for a city via Open-Meteo. It names both the resource (city) and the provider, which distinguishes it from sibling tools such as geo-hint or lib-docs-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 phrasing 'Current temperature for a city' implies that this tool should be used when an agent needs current weather for a city. However, it gives no explicit when-to-use or when-not-to-use guidance and does not mention alternative tools, so the usage context is only implicit.

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

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

With no annotations provided, the description carries the full burden. It does add one useful behavioral detail: 'Body discarded.' But it doesn't disclose that the tool makes an external network request, how redirects or errors are handled, or any rate-limit/privacy implications.

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 appropriately short and front-loaded: it states the output and the key behavioral constraint in one compact 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?

This is a multi-parameter tool with no output schema and no usage differentiation. A single sentence about HTTP status does not explain how to choose among the schema's heterogeneous inputs, what 'shape check' means, or what data the agent should provide to get a useful 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 schema already documents each parameter, so the baseline is 3. The description adds nothing about how the seven parameters relate to the URL-fetching behavior, and some schema entries are marked as 'discarded,' which creates ambiguity about which parameter is actually required.

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

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

The description clearly states the core action: return HTTP status and content type for a public URL, and notes the body is discarded. However, it doesn't distinguish this tool from the sibling fetch-status or browser-url-ok, and the schema's seven heterogeneous fields (ref, city, feed, json, path) are not reconciled with the 'public URL' framing.

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 web-fetch versus fetch-status, normalize-url, browser-url-ok, or domain-shape. The description only says it applies to a public URL, leaving the agent to infer the selection criteria from sibling names.

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 discloses only that the title is discarded after the call, which is useful privacy/state information, but says nothing about return behavior, error handling, network behavior, or what happens for titles that don't exist.

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

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

Two front-loaded sentences with no filler: the first states the operation and the second adds a statefulness note. 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, no annotations, and no parameter that can carry the title the description refers to. The agent is left without a return convention, error semantics, or even an invocable input, so the definition is not complete enough to call correctly.

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

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

The description's central concept, the 'title', is absent from the input schema; the schema exposes only ref, url, city, feed, host, json, and path. The parameter descriptions in the schema point to entirely different concerns, so neither the description nor the schema lets an agent map a title to a usable argument.

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: checking whether a Wikipedia title exists, which distinguishes it from sibling shape/URL/JSON checkers. The purpose is easy to grasp, but it promises a 'title' input that the schema does not expose, so the purpose is only half operationalizable.

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

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

There is no explicit guidance on when to invoke this tool versus alternatives such as normalize-url, validate-json, or the other shape-check siblings. The description implies the use case but gives no exclusions, prerequisites, or context about what kind of title reference is accepted.

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