ISO country PM

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

With no annotations, the description carries the behavioral burden. It transparently discloses that inputs are ignored ('Task text discarded'), surfaces the pay-per-call nature, and states what is returned. It stops short of covering auth, rate limits, or network-call side effects, but there is no annotation contradiction.

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

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

Three short sentences with purpose front-loaded and the discard caveat at the end. Every sentence earns its place and there is no filler; the only mild redundancy is that 'Task text discarded' mirrors the schema's discard notes, but it works as a behavioral flag.

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 7-parameter tool with no output schema and no annotations, the description omits the output format, the relationship between inputs and the returned payload, and whether the call performs network I/O. It covers the core purpose and returns well, but leaves clear gaps an agent would need 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 baseline 3 applies. The description reinforces the discard pattern and contextualizes the heterogeneous parameter set as shape-check-only inputs, but it adds no per-parameter meaning beyond what each schema description already states.

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 + resource — 'Find a public pay-per-call tool gateway (Monid)' — and enumerates the returned payload ('CLI setup, how-it-works, skill file, and remote MCP hops'). This conceptually separates it from the utility siblings (fetch-status, validate-json, web-fetch), though no sibling is explicitly named.

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 scenario is inferable: an agent would call this when it needs Monid's gateway setup, skill file, or remote MCP hops. However, there is no explicit when-to-use / when-not-to-use statement, no named alternatives, and no indication of what input (if any) triggers the lookup.

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

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

The description does disclose a meaningful behavioral trait: no browser is launched, which helps prevent a wrong assumption from the tool name. But annotations are absent, and the description does not state whether a network request is made, whether the check is fully read-only, or what side effects may occur, so the behavioral picture remains 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 purpose is front-loaded, and the second sentence earns its place by preventing a browser-related misinterpretation.

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

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

Given 9 optional parameters, no annotations, no output schema, and many sibling tools, this description is too sparse. It leaves unclear which parameter is the URL to check, what the return value looks like, and whether the extra parameters are even relevant, making reliable invocation uncertain.

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 9 parameters already have descriptions in the input schema, so schema coverage is 100%. The tool description adds no parameter-level detail beyond mentioning 'a URL' and does not clarify how the other parameters relate to the tool, keeping this at the baseline.

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

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

The description states a clear verb ('Check') and resource ('URL'), and the second sentence adds a useful behavioral distinction by saying no browser is launched, which separates it from playwright-url-ok. However, 'can be opened' is ambiguous about whether this means syntactic validity, HTTP reachability, or something else.

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 choose browser-url-ok over siblings like fetch-status, web-fetch, normalize-url, or playwright-url-ok. The 'No browser is launched' sentence only implies one exclusion rather than providing a clear when-to-use or when-not-to-use rule.

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 explaining behavior. The 'Expression discarded' note hints at non-retention, but it does not clarify output format, side effects, failure modes, or how the schema parameters participate in the 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 brief and the action is front-loaded, so it is not bloated. But 'Expression discarded' is a short sentence that creates confusion rather than adding clarity, so the structure is only minimally acceptable.

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 output schema, and no annotations, this description is severely incomplete. It lacks return behavior, parameter roles, error conditions, and selection context, so an agent cannot reliably invoke it correctly.

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

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

The schema covers 100% of parameter names, which earns some baseline credit. However, the description adds no meaningful mapping between the nine schema parameters and arithmetic evaluation, and it references an 'expression' that is not present in the schema, potentially misleading an agent.

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 'Evaluate a+b style arithmetic' names a specific verb and resource, so the basic intent is understandable. However, 'Expression discarded' is ambiguous, and the input schema contains no expression or arithmetic parameter, making it unclear what the tool actually operates on.

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 or when to prefer an alternative. The sibling tools suggest a family of checkers, but the description never explains how calc-eval fits into that family or what conditions call for it.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It adds a useful guarantee ('Page content is not stored'), but it does not mention whether the tool makes a live network request, what side effects or failures may occur, or any restrictions beyond HTTPS.

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

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

Two short sentences, front-loaded with the core function and followed by a privacy note. No filler or redundancy.

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

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

The tool has no output schema and no annotations, yet the description omits the return format, error behavior, and how to choose among the sibling URL tools. The many optional schema params also remain unexplained as a group, leaving an agent under-informed for reliable invocation.

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

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

Schema description coverage is high, so the parameters are already documented individually; the description adds no parameter-level detail. Because the description references only a URL while the schema contains many optional params, it also doesn't clarify how those params relate to the tool's purpose, though the schema's 'discarded' notes partially cover this.

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 states a concrete action and output ('Return host, scheme, and HTTP status for a URL'), so an agent knows what the tool does. It is specific enough, but it does not differentiate from sibling URL tools such as fetch-status or normalize-url, so it stops short of full clarity.

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

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

No guidance is given about when to use this tool versus the many sibling URL utilities (fetch-status, web-fetch, normalize-url, browser-url-ok). There are no alternative names or exclusion conditions, so an agent must guess which tool fits.

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

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

With no annotations, the description carries the burden, and 'No identifiers are retained' is a meaningful behavioral disclosure about privacy and data handling. However, it does not disclose whether any external calls are made, what output is returned, or how the classification behaves with multiple inputs.

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

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

The description is only two sentences long and front-loads its main claim before the privacy note. It is appropriately concise, though the brevity comes at some cost to 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?

With 9 optional parameters, no output schema, and no annotations, the description should explain what classification labels look like and how to choose inputs. It leaves the agent without enough context to call the tool confidently 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?

Schema description coverage is 100%, so the schema already documents all 9 parameters and their discarding behavior. The tool description adds no parameter-specific meaning beyond the general classification statement, so the baseline of 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 says only 'Show how this request is classified,' which is too vague to tell an agent what kind of classification is produced or what input it should provide. It does not mention 'compatibility' or distinguish this from the many sibling shape/check tools.

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

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

There is no guidance on when to use this tool versus siblings like domain-shape, validate-json, or normalize-url. The description implies a classification use case but never says when it is appropriate or which inputs to supply.

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

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

With no annotations, the description carries the full burden. It discloses the main behavior (splitting into labels) and a meaningful limitation (no WHOIS/ownership data), but it does not mention side effects, output format, or what happens when multiple parameters are supplied.

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 front-loaded sentence with no filler. Every word contributes to scope and function, making it easy for an agent to parse quickly.

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

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

For a tool with nine optional parameters, no required fields, and no output schema, a single sentence is insufficient. The agent cannot tell which parameter to pass, whether multiple parameters are accepted, or what the exact return shape looks like.

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' wording maps naturally to the 'host' property, but it does not explain the roles of the other eight optional parameters or indicate which one is required for a meaningful call.

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

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

The description names a specific verb ('split'), a clear resource ('hostname'), and an explicit exclusion ('without WHOIS or ownership data'). This makes the tool's core purpose distinct from URL-normalization or lookup-style siblings, though it does not name any sibling directly.

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 when to use the tool: when you need hostname labels and explicitly do not need WHOIS or ownership enrichment. It does not offer explicit when-not-to-use guidance or name alternatives, so it stops at implied usage.

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

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

The description discloses key behavior: HTTP HEAD, public URL, status-only response, which implies no body and no side effects. However, with no annotations, it does not explain the tool's handling of the many optional inputs (city, json, zone, query) or reconcile those with a pure HEAD operation, leaving the actual behavior ambiguous.

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

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

One short, front-loaded sentence with no filler: 'HEAD a public URL and return status only.' It is easy to parse, though it may be too terse for the breadth implied by the schema.

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

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

With nine optional parameters, no annotations, and no output schema, a single sentence is not enough. The description does not explain how to use the non-URL parameters, what status values mean, or how errors/redirects are handled, so an agent lacks important context for correct invocation and interpretation.

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 parameter descriptions carry the semantics: each field is optional and many are explicitly 'discarded after' a check. The top description adds no parameter-level detail, which is acceptable under the 100% coverage baseline.

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

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

The description names a specific operation (HEAD), resource (public URL), and result (status only), so an agent can tell this is a lightweight availability check rather than a content fetch. It does not explicitly name sibling alternatives, and the nine-parameter schema suggests a broader 'shape status' behavior than the one-sentence description conveys.

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

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

There is no guidance about when to choose fetch-status over web-fetch, browser-url-ok, normalize-url, or status-catalog. The description implies 'when you only need a status', but it never states exclusions or alternatives.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. The only behavioral detail provided is 'Path discarded', which is ambiguous and may refer to either the URL path component or the 'path' input parameter. The description does not state whether the operation is read-only, what it returns, whether it makes network requests, or how invalid URLs are handled.

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

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

The description is extremely compact: two short sentences with no filler or repetition. The core purpose is front-loaded in the first sentence, and the second sentence is an intentional behavioral hint. 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 9 parameters, no annotations, and no output schema, this description is too thin for an agent to call the tool confidently. It does not explain what a successful parse produces, which parameter to populate, what counts as a valid Figma file URL, or what 'Path discarded' means for the result. The agent is left to infer critical invocation details.

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 description. The description adds useful Figma-specific context to the 'url' parameter, but it does not explicitly say which of the 9 parameters is the relevant input or clarify how the other parameters should be treated. It leaves significant ambiguity around 'Path discarded' and the meaning of 'parse'.

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 ('Parse') and a specific resource ('a Figma file URL'), so an agent knows exactly what domain this tool covers. Naming Figma clearly distinguishes it from sibling shape-checking tools like github-repo-shape, jira-key-shape, and wiki-title-ok. The 'Path discarded' note is cryptic but does not obscure the main 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 should be used when an agent needs to parse or validate a Figma file URL, but it provides no explicit usage conditions, exclusions, or alternatives. There is no mention of when to prefer a sibling tool such as normalize-url or browser-url-ok instead. This is minimal, implied guidance.

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

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

With no annotations, the description carries the burden and does add one meaningful behavioral fact: it performs no disk access, so it will not read or mutate the filesystem. However, it does not disclose what 'safe' means or what the result looks like, leaving key behavioral expectations unspecified.

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

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

The description is two crisp sentences and front-loads the core action before the safety trait. No filler; each sentence adds information.

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

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

Despite the high schema coverage, the definition is incomplete for invocation: required is 0 and nine properties are optional, yet the description never says which parameter to pass to check a path or whether extra fields are ignored. There is also no output schema, and the description does not state the return type or error behavior, leaving an agent uncertain about the result of a safe vs unsafe path.

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

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

The schema covers 100% of parameters with individual descriptions, so the baseline is 3 and the description need not repeat them. The description only names 'path,' which matches one property, but it does not clarify why the schema exposes eight other string fields or whether they are accepted alternatives.

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 first sentence states a specific verb ('check') and resource ('path'), and the name file-path-ok reinforces that. It is not a tautology, but it never names or contrasts with sibling *_ok/shape tools, so the agent must infer the boundary from context.

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. 'No disk access' implies the tool is safe to call as a pure syntactic check, but no alternative is named and no condition distinguishes it from browser-url-ok, wiki-title-ok, or domain-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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'via Open-Meteo,' signaling an external network call, but does not state whether the operation is read-only, that most input parameters are discarded, or what error/rate-limit behavior might occur. For a tool with a 9-parameter schema, this is a meaningful transparency 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 sentence with no filler, and it front-loads the core purpose and data source. It earns points for economy, but it is so brief that it omits operational details the agent needs, so it is not 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 9 optional parameters, no output schema, and no annotations, this one-line description is incomplete. It does not tell the agent which parameter to populate, what the return format is, or whether the other parameters are ignored, making reliable invocation harder than necessary.

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 direct mapping from 'a place' to the city parameter, but the schema itself documents each parameter clearly, including 'City name for a public weather hint; discarded after the call.' Thus the schema already carries the parameter semantics.

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

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

The description clearly indicates that the tool returns latitude and longitude for a place and names the external source, Open-Meteo. It is not a tautology and is reasonably distinguishable from sibling tools like weather-hint or timezone, though it lacks an explicit verb and does not specify the input/output 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?

Usage is implied: an agent would use this when it needs coordinates for a place. However, there is no explicit guidance on when not to use it or how it compares to alternatives such as weather-hint or timezone, so it only reaches 'implied usage' rather than clear routing.

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 behavioral information. 'Parse' suggests a non-mutating, local extraction operation, which is useful, but the description does not disclose behavior for invalid or non-GitHub URLs, nor does it specify the 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?

One front-loaded sentence with no filler. Every word contributes to understanding what the tool does.

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

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

The tool has 9 optional parameters, no output schema, and no annotations, yet the description gives no return format, no requirement that url be supplied, and no error behavior. The optional-only schema also conflicts with the apparent need for a GitHub URL, leaving invocation requirements murky.

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 already has a description. The tool description adds the key semantic that the URL should be a GitHub repository URL, something the schema's 'HTTPS URL to normalize or cite' does not explicitly state.

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', with a specific resource, 'GitHub URL', and states the outcome, 'owner and repo'. The GitHub domain also naturally distinguishes it from sibling shape tools like 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 sentence gives a clear trigger: use this tool when you need to extract owner and repo from a GitHub URL. It does not name alternatives or exclusions, so it stops short of a 5, but it provides clear context rather than relying on implication.

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. 'Titles discarded' is a genuine behavioral note and 'current' implies a live snapshot, but the description does not state that it performs a network fetch, whether it returns a plain integer, or what happens on failure or rate limiting.

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 action front-loaded and no filler. 'Titles discarded' earns its place by clarifying that titles are not part of the result.

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

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

For a simple count tool with no output schema and no annotations, the description is minimally usable but incomplete. It leaves the return format, network dependency, and parameter relevance unspecified, and given the nine optional parameters and many sibling tools, a bit more context would materially improve safe 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?

All nine parameters already have descriptions in the input schema, so the description does not need to restate them. However, the description does not map the optional parameters to the counting behavior; an agent cannot tell whether 'feed' or 'url' affects the count, though the 'feed' hint about discarded titles partially aligns.

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 opens with a specific verb, 'Count,' and a clear resource, 'current Hacker News front-page stories,' so an agent immediately knows the operation and target. The added 'Titles discarded' clarifies what is excluded from the result and distinguishes this from generic fetch tools.

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

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

The description implies the correct trigger: use this when you need the number of current Hacker News front-page stories. However, it never names alternatives or exclusion conditions, and among siblings like web-fetch, an agent gets no explicit routing guidance.

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

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

With no annotations, the description carries the full burden, but it only states that the names are 'common' and 'for clock calls'. It does not disclose return format, whether parameters are purely discarded, error behavior, or that this is a read-only lookup.

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

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

A single front-loaded, waste-free sentence immediately places the core subject ('Common IANA timezone names') before the context ('for clock calls'). There is no filler or repetition of schema 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?

For a tool with no output schema and no annotations, the description does not explain what calling it returns, how the nine optional parameters relate to the result, or how an agent should invoke it with meaningful arguments. The mismatch between the description's timezone focus and the schema's shape-check style parameters makes the definition incomplete.

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

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

Schema description coverage is 100%, so the baseline is 3; the tool description adds no parameter meaning. Each schema property is individually documented, although none of them visibly relate to IANA timezone names, leaving a confusing semantic gap 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 names the resource ('common IANA timezone names') and its intended use ('for clock calls'), but states no verb such as 'lists' or 'returns', leaving the operation implicit. It is not a tautology, yet it does not clearly distinguish this from related siblings like timezone or utc-time beyond a vague clock-call context.

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?

'for clock calls' implies when the tool is relevant, but there is no explicit when-to-use guidance or mention of alternatives among the many related sibling tools. The agent must infer that this is the source of zone names rather than a conversion or time lookup.

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

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

Annotations are absent, so the description carries the full burden. It usefully discloses that this is a public fetch and that only group counts are returned, but it does not mention failure behavior, redirects, missing robots.txt handling, or that many input parameters appear unrelated and likely 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 a single, front-loaded, filler-free sentence that communicates the core behavior efficiently. It is slightly under-sized given the nine-parameter schema and absence of annotations, but it is not padded or poorly structured.

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

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

Given nine optional parameters, no required parameters, no output schema, and no annotations, a one-sentence summary is not enough. The description does not explain which argument identifies the robots.txt source, what 'group counts' look like, or why parameters like ref, city, and query exist.

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 baseline 3 applies: every parameter has an individual description. However, the tool description adds nothing about which parameter should be used for robots.txt, and schema descriptions such as 'HTTPS URL to normalize or cite' do not clearly connect to robots.txt retrieval.

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 constrains the result to 'group counts only.' This is specific enough to distinguish the tool from generic fetch/status siblings such as web-fetch or fetch-status, even without naming them.

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

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

There is no when-to-use or when-not-to-use guidance, no mention of which of the nine optional parameters supplies the robots.txt target, and no comparison to sibling tools. With such a broad optional schema, the single purpose sentence leaves the agent to guess how to invoke the tool correctly.

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

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

With no annotations, the description carries the full transparency burden. 'Key discarded' usefully discloses that the key is not retained, and 'Check' implies read-only behavior, but the description does not explain the return value, behavior on invalid keys, or any side effects. Significant behavioral gaps remain.

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

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

The description is very short, front-loaded with the purpose, and contains no filler. The second sentence adds meaningful non-retention information. It is concise, though too terse to cover 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 output schema and no annotations, the description needs to explain both input selection and output semantics. It fails to identify which parameter carries the Jira key or what the tool returns. The generic, unrelated parameter descriptions in the schema make the tool not reliably invocable from the definition alone.

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

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

Although schema description coverage is 100%, none of the nine parameters is described as a Jira issue key, and the description provides no mapping from the Jira key to a schema property. The agent cannot confidently determine whether to use 'ref', 'query', or another parameter for the key, making this less useful than the baseline 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 names a specific resource ('Jira issue key shape') and a specific action ('Check'), so the core purpose is clear and distinguishable from sibling shape tools. However, it does not explicitly state the result of the check, such as a valid/invalid indication.

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, no exclusions, and no mention of related tools like github-repo-shape or domain-shape. The agent is left to infer usage solely from the name and one-line description.

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

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

No annotations are present, so the description is the only transparency signal. It discloses one useful behavior (body is discarded) but says nothing about redirects, timeouts, error handling, permissions, or the fact that many accepted parameters seem to be ignored for this check.

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 with no filler; the core action is front-loaded and the body-discard caveat is a valuable second 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?

For a tool with nine optional parameters and no output schema, this sparse description is insufficient. It does not say which parameter to populate, what the returned HTTP status representation looks like, or why the other parameters exist, leaving an agent to infer too much.

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 and the schema already documents all nine parameters. The description adds no additional parameter-level guidance and its 'public library docs URL' focus is not explicitly mapped to a specific property such as 'url'.

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

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

The description names a concrete action ('HTTP status') and a target ('public library docs URL'), and adds a meaningful constraint ('Body discarded'). It does not explicitly distinguish itself from sibling URL tools like fetch-status or web-fetch, so it stops short of a 5.

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

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

The wording implies when to use it: when you need the HTTP status of a public library docs URL. However, it never says when not to use it or which sibling to prefer for general URL checks, body retrieval, or normalization.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only states 'Values discarded.' It does not say whether the tool is read-only, whether invalid JSON causes an error, whether the URL/host/feed parameters trigger network access, or what the return value looks like. The schema's parameter notes also conflict with a simple local counting operation, so an agent cannot reliably infer 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 the core operation front-loaded and no filler. Both sentences earn their place: one states the purpose, the other states a key behavioral detail.

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

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

For a tool with nine parameters, no annotations, no output schema, and a large sibling list, the description is too thin. An agent cannot tell which field to populate, what the output format will be, or how invalid JSON is handled. The combination of a generic description and confused schema parameter text leaves an invocation-relevant 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 schema covers all nine parameters with descriptions, which normally merits a baseline of 3, but those descriptions are poorly aligned with the tool's stated purpose. The description never says which parameter contains the JSON object whose keys should be counted, and the 'json' parameter is described as 'JSON text to validate; discarded after the check,' which sounds like validation rather than counting. Several unrelated parameters (url, city, feed, host, path) add 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 pair, 'Count keys in a JSON object', which clearly identifies the operation. It also adds a behavioral qualifier, 'Values discarded', that distinguishes counting from validation. However, it does not explicitly differentiate this tool from close siblings such as validate-json or search-query-len, and the 'memory' prefix in the name is unexplained.

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 rather than validate-json, search-query-len, or other count/shape-check siblings. The description states only what the tool does, not the conditions that select it. No exclusions or alternatives are mentioned.

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

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

The description does add a useful behavioral detail: query and fragment are dropped. However, with no annotations provided, the description carries the full burden and does not mention that only the url parameter is meaningful, nor clarify how invalid or non-HTTPS URLs are handled.

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

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

Two short sentences with no filler. The main output is front-loaded, and the second sentence adds a crucial transformation detail without waste.

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 9-parameter, all-optional schema and no output schema, the description is too thin. It does not explicitly say 'pass the url parameter and ignore the rest,' and the presence of host and path input properties creates ambiguity with the host and path outputs. An agent could be uncertain which parameter to populate.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds only the query/fragment-dropping behavior, which is relevant to the url parameter but does not meaningfully explain any of the nine parameters or identify the operative one beyond 'a URL'.

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

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

The description is specific: it names the exact verb ('Return') and the exact resource components ('origin, host, and path for a URL'). This clearly differentiates normalize-url from URL-checking or fetching siblings such as browser-url-ok and web-fetch.

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

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

There is no guidance about when to use this tool versus alternatives, no mention of exclusions, and no note about when not to use it. The purpose implies a use case, but the description never tells the agent how to choose between this and the many URL-related siblings.

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

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

No annotations are provided, so the description must fully disclose behavior, but it only states a negative fact: no browser is launched. It does not say whether a network request is made, what counts as 'opened' (e.g., HTTP 200, DNS resolution, page title), whether side effects occur, or what happens for invalid URLs. The tool's safety and I/O behavior remain significantly underspecified.

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 one short sentence plus a clarifying clause, with the core action front-loaded and no filler. It is appropriately compact for a simple-sounding tool, though the brevity contributes to missing usage and parameter context penalized in 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 a ten-property optional schema, no output schema, and no annotations, this minimal description is incomplete. The agent is not told what result to expect (boolean, status, error), which parameters are relevant, or how this tool relates to browser-url-ok and web-fetch. The ambiguity around 'opened' and the presence of seemingly unrelated parameters create a meaningful risk of incorrect 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?

All ten input properties have individual schema descriptions, so the baseline is 3 even though the tool description itself adds no parameter-level detail. The description does not identify which parameter is the URL to check, and several parameters (city, json, path, ref) seem unrelated to URL openability; even the url property is described in the schema as for 'normalize or cite.' While the schema descriptions cover each field, the description fails to resolve how these parameters relate to the stated tool 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 states a concrete action ('Check') and resource ('a URL'), and adds a useful behavioral qualifier ('No browser is launched'). This gives a clear basic purpose and hints at differentiation from browser-launching siblings like browser-url-ok. However, 'can be opened' is ambiguous (syntactic validity vs. actual reachability), and the description does not explicitly contrast with similar tools.

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

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

The description gives no guidance on when to use this tool instead of alternatives such as browser-url-ok, fetch-status, normalize-url, or web-fetch. 'No browser is launched' implies a lightweight check, but the agent is not told when that property is desirable, what prerequisites exist, or which sibling should be chosen instead. No exclusions or conditional usage instructions are present.

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 explicitly says 'Query discarded', signaling that input is not persisted, which is a useful side-effect note. It still omits return format and behavior when multiple parameters are supplied, but the core non-retaining behavior is disclosed.

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

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

The description is two terse sentences with no filler; the core action is front-loaded. 'Query discarded' earns its place as a behavioral note rather than redundant phrasing.

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 specify that only the 'query' parameter should be passed or that other parameters are ignored. An agent could hesitate about how to invoke this correctly, so the description is not complete for the given schema complexity.

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 nine parameters, including 'query' as 'Search text; discarded after the length check'. The tool description adds no parameter-level meaning beyond that, so the baseline of 3 applies.

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

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

The description states a specific verb ('Count') and resource ('search query'), and the second sentence clarifies the query is not retained. It does not differentiate from sibling counting tools such as memory-key-count or hn-front-count, 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?

The purpose statement implies the use case: use this tool when you need the character length of a search query. However, there is no explicit when-to-use, when-not-to-use, or alternative routing guidance for an agent deciding among siblings.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it provides none. It does not state whether the tool is read-only, what it returns, how inputs are used, or whether any side effects occur. The word 'catalog' weakly implies informational content, but that is not enough.

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 terse, but conciseness becomes under-specification here. A single noun phrase is not appropriately sized for a tool with nine parameters and no annotations or output schema. It saves words by omitting essential operational 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?

The tool is marked as having no output schema and no annotations, yet the description does not explain the return value, the role of the nine optional parameters, or how the HTTP status-code catalog relates to inputs like city, feed, json, and query. This is far too incomplete for an agent to invoke 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%, and each of the nine parameters has its own descriptive schema text, so the baseline is 3 even though the tool description adds no parameter-level meaning. The description does not connect the parameters to the catalog concept, but the schema already documents each field individually.

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

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

The description is basically a noun-phrase restatement of the tool name: 'Short catalog of common HTTP status codes.' It lacks a verb and does not say what the tool does when invoked. It also does not distinguish this tool from siblings like fetch-status or browser-url-ok, and the schema parameters are unrelated to HTTP status codes.

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 or when to prefer an alternative. The description does not mention any sibling tool, filtering conditions, or typical use scenario. An agent cannot infer the intended calling context from the description alone.

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

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

With no annotations, the description carries the behavioral burden. 'Prompt discarded' and 'Return' suggest a read-only, deterministic operation, which is useful. However, it does not clarify whether the optional parameters are also ignored, and it says nothing about error behavior or output persistence, so transparency is only partial.

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

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

Two short sentences, with the main purpose first and the behavioral note second. The fragment 'Prompt discarded' is compact but slightly ambiguous; a more complete phrasing would be equally concise.

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

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

For a tool with no output schema and no annotations, the description gives only the high-level result and one behavior. Since all 9 parameters are optional and schema-documented, the agent can invoke it with no arguments, but it is left to guess why the parameters exist and what exactly the template contains. This is the minimum viable level of 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 coverage is 100%, and every parameter has a description (e.g., 'discarded after the shape check', 'whitespace normalized'). The tool description adds no parameter-level meaning, but none is required because the schema already documents the parameters; baseline 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 uses a concrete verb and object—'Return a three-step thinking template'—so the core operation is clear. The appended 'Prompt discarded' is cryptic, and there is no explicit differentiation from sibling tools, but the intended output is unambiguous.

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

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

The description offers no guidance on when to call this tool or when to prefer a sibling like validate-json, file-path-ok, or normalize-url. It also does not state whether any of the 9 optional parameters should be provided, leaving invocation context 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 must disclose behavior on its own. It names the result but does not say whether the call is read-only, how invalid timezone names are handled, which of the nine schema parameters are relevant, or what output shape is returned.

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 unnecessary words. Its brevity is a strength, even though it contributes to the lack of operational detail.

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

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

For a simple read-only timezone lookup, the core purpose and the zone input are identifiable from the description plus the schema. Still, the absence of an output schema and any error-behavior notes leaves some ambiguity about the returned time format and invalid inputs.

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 the zone property already includes an IANA example, so the schema does the heavy lifting. The description adds only the qualifier 'named', reinforcing that an identifier like Europe/Paris is expected, but it does not explicitly map the description to the zone 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 states that the tool returns the current time for a named IANA timezone, which distinguishes it from sibling tools like utc-time and iana-zones. It is not worded with an imperative verb and leaves the exact parameter name implicit, so it stops short of a top score.

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

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

The intended context is implied: use this tool when a user wants the current time in an IANA-named timezone. However, it does not explicitly compare against utc-time, iana-zones, or other alternatives, nor does it state 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?

No annotations are provided, so the description carries the full behavioral burden. It only states the output and fails to disclose that all accepted input parameters are ignored or discarded, that no side effects occur, or what timestamp format is returned.

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 short and free of filler, making it easy to parse. However, it leans toward under-specification rather than purposeful conciseness, since key behavioral details are omitted.

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 seven input parameters that appear unrelated to time, the description is incomplete. It fails to clarify that parameters are irrelevant to the tool's result or specify the return format, leaving an agent with important gaps.

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

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

The input schema describes each parameter and explicitly notes discard behavior, so schema coverage is high. The description adds no additional parameter semantics, but the baseline is acceptable since the schema already documents 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 is nearly a restatement of the tool name: 'utc-time' becomes 'Current UTC timestamp.' It identifies the output resource but uses no action verb and does not differentiate itself from sibling tools such as timezone.

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

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

There is no guidance on when to use this tool, when not to use it, or what alternatives like timezone or web-fetch might be better suited for. The agent is left to 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?

With no annotations, the description carries the behavioral burden; it does add that the body is discarded, which signals no persistence or side effects. However, it leaves important behavior unspecified: whether invalid JSON returns a boolean, raises an error, and how the other nine supplied parameters are treated.

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 purpose is front-loaded. The terseness is acceptable, though a sentence on result/usage would make it complete.

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

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

For a tool with nine optional parameters, no output schema, and no annotations, this is too thin. It fails to state what the tool returns, which parameter to pass as the JSON body, or how failures are surfaced, so an agent would have to guess at the 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 description coverage is 100%, so the schema already documents every parameter; the baseline is 3. The description's 'body' is not clearly tied to the 'json' parameter and gives no hint about the other eight optional fields, so there is no reason to upgrade.

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 ('check whether') and a clear resource: a body's JSON validity. It is immediately distinguishable from sibling shape/ok tools such as file-path-ok or browser-url-ok because it targets JSON syntax.

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 choose this tool over alternatives. It neither names sibling validation tools nor states conditions such as 'use this for raw JSON strings and browser-url-ok for URL reachability.'

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 reveals an external dependency via Open-Meteo but does not mention side effects, failure modes, rate limits, or that most non-city parameters are discarded. The schema hints at discarding, but the description itself does not.

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 and scannable, though its brevity means some useful guidance is omitted, which prevents a perfect score.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, a one-sentence description is insufficient for an agent to call it correctly. The schema covers parameter meanings, but the overall behavior, expected output format, and the purpose of the extra fields remain unexplained.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds useful context that the city parameter is used for the temperature lookup, but it does not explain the role of the other eight parameters or clarify why they exist. The per-parameter schema descriptions carry most of the semantic weight.

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

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

The description states a concrete function: return current temperature for a city, and it names the data source (Open-Meteo). It is not a tautology and clearly identifies the resource, though it does not differentiate from sibling tools such as 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?

There is no explicit guidance about when to use this tool versus alternatives, and no mention of exclusions or prerequisites. The only implied usage is 'when you need a city temperature,' but sibling comparison and selection criteria are absent.

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 usefully discloses that the body is discarded and that this applies to public URLs, which is meaningful for agent expectations. However, with no annotations available, it does not cover failure behavior, redirects, rate limits, or side effects, leaving a moderate transparency 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 two short sentences with no filler. The most important facts—HTTP status, content type, and body discard—are stated upfront and every phrase adds value.

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

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

The description is too thin for a tool whose schema contains many unrelated-looking fields and no output schema. It does not explain which parameter to use, what happens on invalid or non-HTTP URLs, or what the returned status/content type representation looks like. The conflicting schema entries make this ambiguity more damaging.

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

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

The schema provides descriptions for all seven properties, but the tool description does not clarify that 'url' is the operative parameter. Several schema descriptions, such as 'normalize or cite' and 'weather hint', conflict with the tool's stated fetch-status behavior, which actively misleads an agent about how to invoke the 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 clearly states the core behavior: return HTTP status and content type for a public URL, and discard the body. However, it does not differentiate it from sibling tools like fetch-status or browser-url-ok, so the agent may still need to infer which tool is best.

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 use this tool versus alternatives. The mention of 'public URL' gives a weak context, but the description does not say when not to use it or name any alternative tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The only behavioral trait mentioned is that the title is discarded after the call, but the description does not explain what result the tool returns, whether it performs an actual HTTP lookup, or how errors are handled. This is too thin for an agent to know what 'exists' means in terms of output and 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 concise and front-loaded with the core purpose. The second sentence, while slightly vague, is not wasted because it attempts to communicate the stateless/discard trait. It earns a high score for brevity despite the missing parameter mapping.

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

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

The tool has seven parameters, no annotations, and no output schema, yet the description explains neither how to supply the title nor what the response looks like. The mix of unrelated parameters (Git ref, city, JSON, host) makes this omission particularly costly. The definition is not complete enough for reliable invocation.

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

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

The schema documents seven parameters, but none of them is identified as the Wikipedia title or linked to the tool's purpose. The description adds no mapping between 'title' and ref, url, city, feed, host, json, or path. An agent cannot determine which parameter must be populated to perform the check.

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

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

The description states a specific verb and resource: 'Check whether a Wikipedia title exists.' This clearly distinguishes the tool from sibling URL, file, and repo shape checkers. However, it does not connect the word 'title' to any of the schema's seven parameters, so the purpose is clear at a high level but not fully operational.

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 when-to-use or when-not-to-use guidance and names no alternatives. The only implicit usage is 'when you need to verify a Wikipedia title exists,' which is just a restatement of purpose rather than contextual guidance. There are no prerequisites, exclusions, or comparisons to sibling tools like normalize-url or web-fetch.

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