ISO country PF

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

Annotations already convey idempotence and non-destructiveness; the description adds that task text is discarded and that the tool returns informational artifacts. It does not add further operational context such as authentication, rate limits, or any hidden side effects, so it only modestly extends the annotation-provided 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 three short sentences with no filler. The core purpose and output list are front-loaded, and the final 'Task text discarded' note is a meaningful behavioral caveat rather than padding.

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 lists high-level return categories but does not explain how the seven optional parameters are used or which one an agent should provide to locate the gateway. The schema covers parameter details, but the lack of output schema and ambiguous 'Task text discarded' phrasing leave some invocation context 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?

All seven input parameters have detailed schema descriptions (100% coverage), so the description does not need to repeat their meanings. The description adds no additional parameter-level guidance about how these inputs relate to the gateway lookup, 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 uses a specific verb ('Find'), a distinctive resource ('public pay-per-call tool gateway (Monid)'), and enumerates the delivered artifacts ('CLI setup, how-it-works, skill file, and remote MCP hops'). This clearly distinguishes the tool from the many sibling probe/validation 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 first sentence provides a clear use case: use this tool when you need to locate a Monid gateway and obtain its setup and connection details. It does not name alternatives or exclusions, but the purpose is specific enough that an agent can infer when it applies.

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 disclosing behavior. It only reveals that no browser is launched and that a URL check occurs. It does not mention whether a network request is made, whether any input is discarded, what side effects might occur, or what the response indicates. This is insufficient for a tool with no annotations or output schema.

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

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

The description is extremely concise: two short sentences, with the core purpose front-loaded and the key behavioral contrast ('No browser is launched') placed second. There is no filler or redundant wording. Every sentence earns its place.

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

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

The tool has 9 optional parameters, no annotations, and no output schema, so the description needs to provide substantial context. It only covers the URL-checking idea and omits the relevance of the other parameters, the meaning of 'opened', possible return values, and failure behavior. The context provided is too thin for an agent to invoke this tool correctly across its full parameter surface.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description itself adds no parameter-level detail. The description mentions only 'a URL', while the schema documents nine distinct optional parameters. The schema descriptions do provide some semantics, so the description is not penalized heavily, but it also does not clarify how the many unrelated parameters relate to the stated URL-checking 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 clear action and resource: 'Check whether a URL can be opened.' The additional sentence 'No browser is launched' helps differentiate it from browser-launching siblings like playwright-url-ok. However, it does not define what 'opened' means (HTTP reachability, URL syntax, etc.), and the input schema includes many non-URL parameters, making the stated purpose narrower than the schema suggests.

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 explicit guidance about when to use this tool versus alternatives like fetch-status, normalize-url, or playwright-url-ok. 'No browser is launched' hints at a lightweight check, but it does not state conditions, exclusions, or preferred contexts. The agent is left to infer usage from the tool name and 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 carries the full burden of behavioral disclosure. It does disclose that the expression is discarded, which is a useful retention trait, but it says nothing about return values, error behavior, supported operators, side effects, or security considerations. This is thin for a tool with zero annotation coverage.

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 with the core action; there is no filler. The second sentence is slightly cryptic, but it does add a behavioral clue that the input is not retained. It is concise without being bloated, though the brevity contributes to under-specification elsewhere.

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

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

With nine parameters, no annotations, and no output schema, the description is far from complete. It does not specify which parameter carries the expression, what the tool returns, or how the expression is interpreted. An agent would be guessing how to invoke calc-eval correctly, making this definition inadequate for the tool's 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 schema has 100% description coverage, so the baseline is 3, but the description fails to connect its mentioned 'expression' to any actual schema property. The nine properties are unrelated to arithmetic (ref, url, city, feed, host, json, path, query), so an agent cannot determine which parameter to populate. The description adds no useful parameter-level meaning and instead creates 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 names a specific action and target ('Evaluate a+b style arithmetic'), which gives a surface-level purpose. However, it never clarifies how the expression is supplied, and none of the nine schema properties is an expression parameter. It also does not distinguish this tool from sibling shape-check or eval-style tools beyond the terse wording.

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 calc-eval versus alternatives like domain-shape, validate-json, or search-query-len. No exclusions or selection criteria are given; the only signal is the arithmetic phrase, leaving the agent to infer applicability from the tool name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does add one useful guarantee—'Page content is not stored'—but it does not say whether the URL is fetched, how HTTP status is obtained, whether redirects are followed, or what side effects may occur. This is under-disclosed for a URL-touching 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?

Two short sentences with no filler. The core behavior is front-loaded, and the privacy note is a meaningful 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?

The tool's schema exposes seven to nine parameters covering URL citation, city names, feeds, JSON validation, and paths, yet the description only addresses the URL case. An agent would not understand the tool's full scope, which parameters to use together, or what happens when non-URL parameters are provided. The absence of an output schema makes this incompleteness more costly.

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 real parameter meaning beyond the schema; it only reinforces the 'url' use case while remaining silent on 'ref', 'city', 'feed', 'json', 'path', and 'host'. The schema descriptions already handle most 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 states the tool's main behavior: 'Return host, scheme, and HTTP status for a URL.' This is a specific verb and resource with a concrete output. However, it does not distinguish the tool from siblings like fetch-status or normalize-url, and it ignores the many non-URL parameters in the schema.

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

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

There is no guidance about when to use this tool versus alternatives such as fetch-status, status-catalog, browser-url-ok, or normalize-url. The description implies a URL-status use case but does not state exclusions, prerequisites, or preferred conditions.

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

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

With no annotations, the description carries the full behavioral burden. It adds useful privacy context by stating 'No identifiers are retained,' and the parameter descriptions reinforce statelessness with 'discarded' notes. However, it does not disclose whether the tool is read-only, whether it makes external calls, or what it does with the inputs before discarding them.

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 privacy statement earns its place. The first sentence, though vague, is front-loaded and 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?

With 9 optional parameters, no output schema, and no annotations, the description should explain the classification output, return format, and when to invoke the tool. It provides none of that, leaving an agent unable to confidently use the tool or interpret its result.

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

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

Schema description coverage is 100%, so each parameter already has a clear individual description. The tool-level description adds no parameter-level meaning beyond what the schema provides, so the baseline score 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 verb ('Show') and a resource ('how this request is classified'), but 'classified' is vague and the classification scheme or output is never defined. It does not distinguish this tool from the many sibling shape-checking and validation 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 its siblings, and it does not mention any alternatives or exclusions. An agent cannot tell whether compatibility should be called before a specific shape-check tool or instead of 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 transparency burden. It does disclose one useful behavioral trait: no WHOIS or ownership lookup is performed. But it does not describe the output format, error behavior, or whether input normalization happens, leaving meaningful behavioral gaps.

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

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

The description is a single front-loaded sentence with no filler. It efficiently states the operation, the resource, and a key limitation.

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, one operation sentence is insufficient. The description does not say which parameter to pass, what the returned labels look like, how invalid hostnames are handled, or what the many unrelated schema fields are for.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level detail beyond implying the `host` parameter, and it does not explain how the other eight optional parameters relate to a hostname-splitting 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 names a specific verb ('Split'), resource ('hostname'), and result ('labels'), and adds a key limitation ('without WHOIS or ownership data'). This clearly differentiates it from ownership-enrichment tools and from sibling 'shape' tools that target URLs, repos, or file paths.

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 usage is implied: use this when you need hostname labels and do not need WHOIS or ownership data. However, it names no alternative tools and gives no explicit when/when-not guidance, so an agent has to infer selection context on its own.

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 is the sole source of behavioral information; it correctly reveals a non-body HEAD request and a status-only result. However, it does not disclose behavior on redirects, timeouts, unreachable hosts, or whether the other eight schema parameters are ignored, which is significant given the large optional parameter list.

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: verb, target, and return type are all immediately visible. It earns its place and leaves only behavioral/contextual gaps that are scored elsewhere.

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

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

Given no annotations, no output schema, and nine optional parameters, a one-sentence description is insufficient for reliable invocation. It tells an agent what the tool does but not which parameter to populate, what the status output looks like, or how errors/failures are represented.

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

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

Schema coverage is 100%, so the baseline is 3 even without parameter details in the description. The description adds a weak signal that `url` is the relevant parameter, but it does not clarify that the other eight parameters are unused, and the schema's own `url` description ('normalize or cite') is not tailored to HEAD-status 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 clear operation (HEAD), a resource class (public URL), and an output contract (status only), so an agent immediately knows what the tool does. It does not explicitly name a sibling alternative, but 'status only' helps distinguish it from content-fetching tools like web-fetch.

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

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

The description implies when to use it—when only the HTTP status of a public URL is needed—rather than stating it explicitly. It gives no named alternatives, no exclusions, and no prerequisites beyond public accessibility, so the agent must infer the boundary with sibling tools.

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

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

With no annotations, the description carries the full burden. It discloses one behavior ('Path discarded') and implies read-only parsing, but does not state whether the URL is fetched, what is returned, how invalid URLs are handled, or whether any side effects occur.

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

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

Two short sentences, action first, then the key exception. There is 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?

For a tool with nine schema parameters, no output schema, and no annotations, the description is too thin: it does not define the return value, error behavior, or the expected input parameter. An agent would struggle to invoke it confidently beyond guessing `url`.

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 and the description need not repeat parameter docs. The description adds the useful hint that the URL is a Figma file URL and that the path component is ignored, but it never names `url` as the operative parameter among the many 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?

States a specific action ('Parse') and distinct resource ('a Figma file URL'), and notes a behavioral constraint ('Path discarded'), which separates it from generic URL tools like normalize-url. It does not explicitly say it validates a URL's shape, but the name and siblings make that inferable.

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 on when to use this tool versus sibling tools such as normalize-url, browser-url-ok, or github-repo-shape. The only usage hint is implied by 'Figma file URL'; there are no exclusions, prerequisites, or alternative 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?

The description usefully discloses a key behavioral trait: it performs no disk access, so it cannot verify existence or permissions. However, with no annotations, the description carries the full behavioral burden, and it does not define what 'looks safe' means or state the return/error 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?

Two short sentences with no filler. The core action is front-loaded, and the important safety qualifier 'No disk access' is placed immediately after the main claim, making it easy for an agent to parse.

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

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

For a tool with 9 optional parameters, no required parameters, no output schema, and no annotations, this description is not complete enough. It does not tell the agent which parameter to supply, whether multiple parameters are allowed, or what a successful check returns. The mismatch between the path-focused description and the multi-purpose schema creates a serious invocation gap.

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

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

The input schema already describes all nine optional parameters at 100% coverage, which sets the baseline at 3. The tool description adds no parameter-level meaning beyond singling out 'path'; it does not clarify how the many unrelated schema properties relate to this path-focused 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 uses a specific verb ('Check') and resource ('path') and adds a key qualifier: it only checks whether the path 'looks safe' and performs no disk access. This distinguishes it from sibling URL, domain, and title validators, though it does not name them. The unusually broad input schema with URL, city, JSON, zone, and query parameters muddies the actual scope, but the description itself is specific.

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

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

There is no guidance on when to use this tool versus sibling validators such as wiki-title-ok or normalize-url. 'No disk access' implies an offline pre-check, but the description does not explicitly state when to prefer it, when not to use it, or which alternatives to consider.

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 mentions Open-Meteo as an external service, which hints at a network dependency, but it does not disclose that inputs may be discarded, that data is fetched remotely, or what the response format is. This is minimal disclosure at best.

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

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

The description is a single, front-loaded sentence with no wasted words. It is concise, though the extreme brevity contributes to the lack of context penalized elsewhere.

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

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

With nine optional parameters, no output schema, and no annotations, an agent needs more guidance about which parameter to provide and what the response will look like. The description only gives the output concept, not enough to invoke the tool confidently.

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

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

Schema description coverage is 100%, so the parameters are already documented. However, the description does not clarify which parameter supplies the 'place' — city, query, or something else — which limits its added value. The schema carries the semantic weight here.

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 latitude and longitude for a place via Open-Meteo, which is a clear, specific purpose even though it lacks an explicit verb. It does not differentiate from sibling tools like weather-hint, but the core function is understandable.

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

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

There is no guidance on when to use this tool versus alternatives such as weather-hint or timezone. The description only says what it does, not when it should be selected or when it should not be used.

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 burden of behavioral disclosure. It does state the core behavior of extracting owner and repo, and 'parse' suggests a non-destructive operation, but it does not describe how invalid or non-GitHub URLs are handled or whether normalization occurs. For a simple parse operation this is adequate but not detailed.

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

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

A single front-loaded sentence contains no filler and does not repeat schema content. Every word contributes to the tool's operational purpose.

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

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

For a simple parse-only tool, the description adequately conveys the core input and output. However, the schema exposes eight additional optional parameters with no guidance about which are irrelevant, and there is no output schema or statement about the return shape. This leaves minor but real ambiguity for an agent selecting and invoking the tool.

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

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

Schema coverage is 100%, establishing a baseline of 3. The description adds meaningful semantics by indicating that the `url` parameter should be a GitHub URL for owner/repo extraction, which counteracts the schema's generic 'HTTPS URL to normalize or cite' wording. It does not explicitly name the parameter, but the mapping is clear.

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 begins with a specific verb, 'Parse', names the exact output ('owner and repo'), and scopes the input to a 'GitHub URL'. This clearly distinguishes github-repo-shape from sibling shape tools such as 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 wording implies the tool should be used when the agent has a GitHub URL and needs owner/repo extraction, but it does not explicitly state when not to use it or mention alternatives like normalize-url or domain-shape. This is implied usage rather than explicit 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?

With no annotations supplied, the description carries the behavioral disclosure burden. 'Current' indicates a live fetch and 'Titles discarded' says story titles are not returned, but it does not state the return format, network dependency, or whether all input parameters are ignored.

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

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

Two short sentences with no filler. The core action is front-loaded and the second sentence provides the most important output constraint.

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

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

The definition lacks an output schema, yet does not describe what the returned value looks like. It also does not clarify how to handle the nine optional parameters, most of which appear unrelated to Hacker News counting; an agent could reasonably be unsure whether any arguments are needed.

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 only the repeated 'Titles discarded' fact and does not explain how the nine optional parameters relate to the count operation, leaving the baseline at 3.

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

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

The description uses a specific verb ('Count') and a clear resource ('current Hacker News front-page stories'), and 'Titles discarded' clarifies that the result is a count rather than story titles. This distinguishes it from sibling URL/shape-check tools.

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

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

The intended use is implied: call it when you need the number of current HN front-page stories. However, it gives no explicit when-not-to-use guidance or alternative tool names, and 'Titles discarded' is only an implicit exclusion.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior, and it says nothing: no indication of whether this is a read-only list, whether it validates input, what it returns, or what 'common' means as a subset. Given 9 schema parameters that reference Git refs, URLs, weather cities, RSS feeds, and JSON — most marked as 'discarded' — the missing behavioral context is especially costly.

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 six words with zero filler, which is genuinely concise, but it is a sentence fragment with no verb, crossing from conciseness into under-specification. A fuller phrase such as 'Returns the list of common IANA timezone names to pass to clock calls' would preserve the length and add the missing operation.

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 is responsible for explaining return values and safety, and it does neither. The confusing 9-parameter schema (params like ref, url, city, and json marked as 'discarded') is unexplained, and the tool's relationship to the timezone and utc-time siblings — which presumably consume these names — is never stated.

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 and the baseline of 3 applies. The description adds no parameter-level meaning, and notably it never says which parameter carries the timezone query, but at 100% coverage the schema carries the 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 is a noun phrase — 'Common IANA timezone names for clock calls' — that identifies the subject matter but omits the operation. An agent cannot tell whether the tool lists, validates, or filters these names, and it does not explicitly differentiate from the sibling tools 'timezone' and 'utc-time'. The purpose is only vaguely implied.

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 the tool is meant to supply zone-name inputs for clock/time operations, but there is no explicit when-to-use guidance, no stated exclusions, and no mention of the alternative tools (timezone, utc-time) that would consume these names. The relationship between this tool and its siblings is left entirely to inference.

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

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

With no annotations provided, the description carries the disclosure burden. It usefully reveals that this is a public read operation and that the return value contains only group counts. However, it does not disclose error behavior, redirect handling, or the fact that most of the nine schema parameters appear unrelated and are discarded.

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

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

The description is a single front-loaded sentence with no filler. 'Fetch a public robots.txt' states the action immediately, and 'return group counts only' adds a precise output constraint.

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

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

The tool has nine optional parameters, no required parameters, and no output schema, yet the description never explains how to choose the target robots.txt URL or which parameters are actually used. This is a significant invocation gap despite the clean one-sentence description.

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

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

Schema description coverage is 100%, so the baseline of 3 applies even without parameter details in the description. The description adds no parameter-level meaning and does not explicitly say that 'url' is the robots.txt target, but it does not need to compensate for missing schema documentation.

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 ('Fetch') and a concrete resource ('public robots.txt'), and 'return group counts only' clarifies the output shape. It is clear enough to distinguish this from generic web fetching, though it does not name any sibling tool explicitly.

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 instead of alternatives such as web-fetch, fetch-status, or browser-url-ok. The intended context is only implied by the tool name and the phrase 'public robots.txt', leaving the agent to infer the appropriate selection conditions.

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. 'Key discarded' discloses disposal of the input, but there is no mention of return behavior, error semantics, or whether the check is purely syntactic. This is insufficient for a standalone validation 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 short and front-loaded, but the second sentence is cryptic and the word 'shape' is repeated. It is concise without being informative enough to compensate for the complex, unrelated input schema.

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

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

With nine optional parameters, no output schema, and no annotations, the tool needs more guidance to be called correctly. The description does not say which parameter holds the Jira key, what the check returns, or what a shape-conforming key looks like, so an agent cannot reliably select and 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?

Although the schema has 100% description coverage, the parameters appear unrelated to a Jira issue key: url, city, feed, host, json, path, zone, and query are all present, but no 'key' parameter exists. The description does not map its core concept to any schema property, leaving ambiguity about which input should contain the Jira key.

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

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

The description states a specific action ('Check') and resource ('Jira issue key'), which distinguishes it from sibling shape-checkers like domain-shape or github-repo-shape. However, it does not clarify what 'shape' means or what constitutes a valid or invalid Jira key.

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 usage when validating a Jira issue key, and the sibling list hints at specialized shape-check tools. Yet there is no explicit when-to-use, when-not-to-use, or alternative routing like 'for GitHub refs use github-repo-shape instead.'

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

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

With no annotations, the description alone must disclose behavior. It does reveal that the body is discarded, which is useful, but it omits whether this performs a network request, any side effects, redirect handling, output format, or error behavior. The behavioral disclosure is too thin for a tool with no annotation support.

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

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

The description is extremely concise and front-loaded, with both sentences carrying information ('HTTP status' and 'body discarded'). It sacrifices completeness for brevity, but as a concise statement it has no wasted words.

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

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

Given nine optional parameters, no output schema, and no annotations, the description is not complete enough to invoke correctly in all cases. It covers only a single URL-status use case and leaves the roles of the city, json, zone, query, feed, ref, host, and path parameters unexplored in the tool description, despite the schema documenting them individually.

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 already explains each parameter. The description adds no parameter semantics beyond implying that url is the relevant one, and it does not clarify how the other eight optional parameters relate to the stated URL-status 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 operation — return the HTTP status of a public library docs URL and discard the body — so it is not a tautology. However, the 9-parameter schema includes city, json, timezone, and query inputs, which are not reflected in this stated purpose, making the tool's actual scope ambiguous and failing to differentiate it from close siblings like fetch-status or status-catalog.

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

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

No guidance is given for when to choose this tool over alternatives such as fetch-status, web-fetch, browser-url-ok, or status-catalog. There are no conditions, exclusions, or examples of appropriate use beyond the implied 'when you need an HTTP status for a library docs URL'.

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

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

The description does disclose the non-obvious behavioral trait that values are discarded, which adds value beyond the tool name. However, with no annotations, it still does not state whether top-level keys only are counted, what happens with invalid or empty JSON, or what the return value looks like.

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

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

The description is two short sentences with the core operation front-loaded and no filler or repetition. Every word earns its place, and it is appropriately sized for a simple utility.

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, the description is under-specified. It does not state how the JSON object should be passed, whether an empty object is valid, or what the count result looks like, making correct 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?

Schema coverage is 100%, and each parameter description reinforces that values are discarded, which aligns with the tool description. The description itself adds no parameter-specific meaning, and the 'json' parameter is framed as 'validate' rather than 'count keys in', leaving the mapping implicit.

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 concrete operation ('Count keys in a JSON object') and adds a useful qualifier ('Values discarded'). It is clear enough to distinguish from validation-focused siblings like validate-json, though it does not explicitly name an alternative or identify which JSON object should be counted.

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 when-to-use guidance or exclusions are given. The description does not mention alternatives such as validate-json, nor does it explain which parameter should carry the JSON input, so the agent must infer usage from the name and schema 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?

No annotations are present, so the description carries the behavioral disclosure burden. It does disclose a key transformation: query and fragment are dropped. However, it does not describe output format, error behavior, or the role of the many optional parameters, several of which are described in the schema as 'discarded'.

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

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

Two short sentences with no filler. The main output and the key behavioral caveat are front-loaded, making the description easy 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?

The description is too thin for a tool with 9 optional parameters, no output schema, and no annotations. It only addresses URL normalization and gives no context for the unrelated-looking parameters such as ref, city, json, zone, and query, leaving an agent uncertain about how to construct a full call.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds URL-related meaning (origin, host, path, dropping query/fragment) but leaves the other eight parameters unexplained; the schema descriptions do most of the semantic 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 states a specific verb and resource: 'Return origin, host, and path for a URL' and adds a clear behavioral detail that query and fragment are dropped. It is understandable on its own, though it does not explicitly differentiate this from URL-related siblings such as figma-url-shape or browser-url-ok.

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, or when not to use it. The behavior implies a URL normalization/quoting use case, but the description never names an alternative, condition, or exclusion.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds one useful fact ('No browser is launched') but does not state whether the check involves a network request, what side effects occur, or any requirements such as authentication or rate limits. The behavior beyond the schema is largely undisclosed, leaving an agent to guess the mechanism.

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

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

The description is concise and front-loaded: the main action is stated first, followed by the no-browser clarification. However, it is under-specified rather than economically complete, omitting the tool's full scope and the nature of the check. Two short sentences earn their place, but the content is too thin to fully serve an agent.

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

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

For a tool with seven parameters and no output schema, the description is incomplete. It does not explain what 'opened' means, how non-URL parameters map to the tool's purpose, what the return value looks like, or the behavioral boundary between validation and network access. An agent cannot confidently invoke this tool based solely on the description.

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

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

The input schema provides detailed descriptions for all seven parameters (e.g., 'discarded after the shape check', 'HTTPS URL to normalize or cite'), so schema coverage is 100%. The tool description itself adds no parameter-level information, which is acceptable given the high schema coverage. However, the mismatch between the description's URL-only focus and the schema's broad parameter set creates confusion about when each parameter is relevant.

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

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

The description states a specific verb and resource ('Check whether a URL can be opened') and the 'No browser is launched' clause differentiates from browser-url-ok. However, it is ambiguous whether 'opened' means a network check or a syntactic shape check, and the schema reveals support for city, feed, json, path, and host inputs that the description fails to mention. This narrow, unclear scope makes it inadequate as a 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 explicit when-to-use guidance or mention of alternatives. The 'No browser is launched' phrase is an implicit behavioral hint, but an agent cannot tell whether to choose this tool over fetch-status, normalize-url, or browser-url-ok based on the description alone. The tool's conditions of use are effectively left to inference.

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

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

With no annotations, the description carries the full behavioral transparency burden. It does disclose that the query is discarded, which is useful, but it does not explain what happens to the other eight optional parameters, whether they are ignored, or what the tool returns. This is a significant 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, front-loaded with the action, and contains no filler. The second sentence earns its place by adding the discard behavior. Structurally it is clean and efficient.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, the description is too thin. It does not clarify which parameter is the search query, whether the other fields are ignored, or what result the caller should expect, making confident invocation difficult.

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 new parameter semantics beyond restating that the query is discarded, which is also already in the schema. 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 states a clear action and object: count characters in a search query. It is distinguishable from sibling count/shape tools by its focus on search-query length. However, the nine-parameter schema introduces ambiguity about whether the tool also handles URLs, cities, JSON, paths, etc., which the description does not resolve.

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 guidance, no exclusions, and no comparison to alternatives. An agent can only infer 'use this when you need a character count,' but there is no explicit context helping it choose this tool over other count-oriented 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 but only hints at a read-only, limited 'short catalog.' It does not disclose whether the many input parameters affect behavior, whether it returns a map or a single code, or what side effects/requirements 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?

The single sentence is short but under-specified; it saves words at the expense of operational detail. There is no front-loaded action, no usage context, and no structure that helps an agent invoke the tool.

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 loosely related optional parameters, no annotations, no output schema, and a large set of sibling tools, this description is severely incomplete. An agent cannot determine what to pass, what it will get back, or why it should call this instead of a sibling.

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 all nine parameters already have individual descriptions and the baseline is 3. The tool description adds no parameter meaning and does not connect the catalog purpose to parameters like url/ref/json, but the schema itself covers them.

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

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

The description is a noun phrase, 'Short catalog of common HTTP status codes,' that essentially restates the tool name without an action verb. It identifies the domain but not what the tool does (return a list? look up a code? validate one?), and it does not distinguish it from sibling tools like fetch-status.

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

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

There is no guidance on when to use status-catalog versus alternatives such as fetch-status or normalize-url. The description neither states conditions nor points to sibling tools, so an agent has no basis for choosing 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?

No annotations are present, so the description carries the behavioral disclosure burden. It does disclose a non-obvious behavior: the prompt is discarded. However, it does not clarify whether any of the nine optional inputs affect the returned template, nor what the three-step template actually contains. This is minimal but not contradictory disclosure.

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. It contains no filler. The second sentence, 'Prompt discarded,' is terse and somewhat opaque, but the overall length is appropriate for a simple tool.

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

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

With no annotations and no output schema, the description is the only source of context. It states the returned artifact and one discard behavior, but omits when to use the tool, what the three-step template looks like, and how the optional inputs relate to the output. For an agent selecting among 27 siblings, this 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?

Schema description coverage is 100%, so the baseline is 3 and the description need not repeat parameter details. Each parameter already documents its discard behavior. The description adds no parameter-level meaning, but the schema fully compensates.

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

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

The description uses a specific verb ('Return') and names a concrete resource ('three-step thinking template'), making the core function clear. It does not explicitly distinguish itself from siblings, but the resource is distinctive among the many shape-check and hint tools listed. The phrase 'Prompt discarded' adds a qualifier, though it is not a substitute for a 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 about when to use this tool over the many sibling tools such as validate-json, web-fetch, or calc-eval. 'Prompt discarded' implies an exclusion, but it is not framed as usage guidance and no alternative tool is named. An agent would have to infer when this template is appropriate.

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

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

No annotations are provided, so the description carries the full burden, but it only states the expected output. It does not disclose that none of the schema parameters actually represents a timezone, nor does it mention output format or invalid timezone handling.

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

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

The description is a single, front-loaded sentence with no wasted words. It is concise but slightly too sparse to be a fully effective definition.

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 multiple unrelated parameters, no output schema, and no annotations, this description is far from complete. It fails to explain how to provide the IANA timezone, what the response looks like, or why the schema contains unrelated parameters.

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

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

Although schema coverage is 100%, every listed parameter (ref, url, city, feed, host, json, path, query) is either unrelated to timezones or explicitly described as discarded. The description introduces the 'named IANA timezone' concept but never maps it to any schema property, making invocation impossible to infer.

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

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

The description clearly states the tool returns the current time for a named IANA timezone, which distinguishes it from siblings like iana-zones and utc-time. It lacks an explicit verb, but the intended purpose is unmistakable.

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

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

There is no guidance on when to use this tool versus alternatives such as utc-time or iana-zones. The use case is only implicit in the phrase 'named IANA timezone', with no exclusion or alternative 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?

With no annotations, the description carries full responsibility for behavioral disclosure. It only states the primary output, but does not explain that the tool ignores or discards its input parameters, nor does it mention return format or potential side effects. The schema descriptions hint at discarded parameters, but the tool description itself omits this important 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 very brief with no wasted words, and the core concept is front-loaded. However, it is perhaps overly terse given the complex input schema, but for conciseness alone it is effective. It earns a high score for brevity, though not perfection due to the lack of a complete sentence.

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

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

The tool has a surprisingly rich input schema with seven parameters that are unrelated to the apparent purpose, and the description provides no explanation for them. Without any output schema or further context, an agent cannot confidently determine whether parameters need to be supplied or what the tool does with them. The description is incomplete for the tool's actual 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 schema provides descriptions for all seven parameters, each noting they are 'discarded' or used transiently, so parameter documentation is fully covered. The tool description adds no additional meaning about parameters, so the baseline score of 3 applies. The description does not clarify why these parameters exist on a UTC timestamp 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 'Current UTC timestamp.' clearly states that the tool returns the current UTC time, which is a specific output. It is distinguishable from sibling 'timezone' since it explicitly specifies UTC, though it does not name alternatives. The purpose is clear, but the phrasing is terse and could be more explicit as a full sentence.

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 indication of when to use this tool versus alternatives like 'timezone' or other timestamp-related tools. There is no mention of context, prerequisites, or scenarios where it should or shouldn't be used. The presence of unrelated parameters further confuses usage without any 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 transparency burden; it does disclose that the body is discarded, suggesting no persistence. However, it does not describe return behavior, error handling for invalid JSON, or what 'valid' covers.

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

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

The description is short and front-loaded, with no filler; the discard note is a meaningful behavioral addition. It could have added a bit more structure or clarified the parameter, but as written it is economical.

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 too thin. It omits return/error behavior, fails to clarify which parameter supplies the body, and leaves the many unrelated schema parameters 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 description coverage is 100%, so the baseline applies even though the description adds no parameter details. The description does not map 'body' to the json parameter, which is a minor gap, but the json parameter description itself clarifies the intended input.

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

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

The description states a specific action and resource: checking whether a body is valid JSON. This clearly differentiates it from sibling shape-check tools oriented to URLs, paths, and domains, though the term 'body' is slightly vague without a matching parameter 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?

Usage context is only implied: an agent can infer validate-json is for JSON validity checks rather than the URL/path/wiki shape checks in the sibling list. There is no explicit when-to-use guidance, exclusions, or mention of alternatives.

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

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

No annotations are provided, so the description must carry the behavioral burden. It only mentions fetching a temperature, but does not disclose that most parameters are discarded after validation, that city is discarded after the call, or what the actual output shape is. This is a significant transparency gap for a tool with 9 parameters.

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

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

The description is a single sentence with no wasted words and states the primary function upfront. It is concise and well-structured, though the brevity contributes to missing behavioral and contextual 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 9 optional parameters and no output schema, the description is far too thin. It does not explain the role of the other parameters, what the tool returns, or why those parameters exist. An agent would be uncertain how to invoke the tool correctly for anything beyond a basic city temperature query.

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 nothing beyond naming 'city,' but the schema already documents each parameter, including which are discarded. No additional semantic value is needed from the description for parameter understanding.

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: returning current temperature for a city via Open-Meteo. It is clear and matches the tool name, but it does not differentiate the tool from siblings like geo-hint or web-fetch, and the broad schema hints at additional functionality not reflected in the description.

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, and no mention of the unrelated parameters (ref, url, json, path, etc.) that the schema accepts. A one-line description gives no context for choosing this tool over similar 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 present, the description carries the transparency burden. It usefully discloses that the response includes status and content type while the body is discarded, but it does not explain redirect handling, error behavior, rate limits, or whether authentication is ever required.

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

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

The description is two short, front-loaded sentences with no filler. It immediately communicates the output ('HTTP status and content type') and the key limitation ('Body discarded').

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 heterogeneous seven-parameter schema and no output schema, the description is incomplete. It only explains the URL case, leaving the meaning and expected usage of ref, city, feed, json, host, and path unexplained, so an agent cannot confidently invoke the tool for those input types.

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 seven parameters, so the description does not need to repeat them. However, the description also does not clarify how non-URL parameters like ref, city, feed, json, or path relate to the stated 'public URL' 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 behavior: it returns HTTP status and content type for a public URL, and explicitly notes the body is discarded. This clearly distinguishes the core purpose from normalizing or validating tools, though it does not address the non-URL parameters in the schema.

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

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

No guidance is given about when to use this tool versus siblings like fetch-status, normalize-url, or validate-json. The only contextual hint is 'public URL', but there are no exclusions, alternatives, or conditions for selecting this tool.

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. It discloses that the title is discarded after the call, but it does not say whether the tool fetches Wikipedia, returns a boolean, fails on missing titles, or has rate limits or other 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 only two short sentences with the purpose front-loaded and no filler. It loses a point because the extreme brevity leaves critical operational details unstated, but as concise writing it is effective.

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

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

For an 8-parameter tool with no annotations and no output schema, the description is not complete enough. It omits the input mapping, expected return value, and any failure behavior, so an agent lacks the context needed to invoke it correctly.

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

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

The schema documents eight properties, but none is named 'title' and the description never maps the Wikipedia title to any of them. Baseline schema coverage is high, yet the central input for this tool is not connected to the schema, so an agent cannot determine what to pass.

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

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

The first sentence states a concrete action and resource: checking whether a Wikipedia title exists. It is clear but does not differentiate this tool from the many other *-ok and *-shape siblings, and the schema contains no visible 'title' parameter.

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 wiki-title-ok versus related tools such as browser-url-ok, normalize-url, web-fetch, or other shape-checking siblings. The description does not mention alternatives, prerequisites, or exclusions.

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