ISO country PL

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

With no annotations, the description carries the behavioral disclosure burden. It does disclose a non-obvious behavior ('Task text discarded') and lists what it returns, but it does not mention read-only status, auth requirements, rate limits, or failure behavior. This is useful but incomplete for a tool that contacts a public gateway.

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, no filler. The purpose is front-loaded, the return artifacts are concrete, and the discarded-task-text warning is a useful behavioral caveat. Every sentence earns its place.

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

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

For a tool with seven parameters and no output schema, the description lists four return categories but does not explain how to select parameters, what the returned values look like, or what happens on failure. The rich schema descriptions partly compensate, making this an adequately minimum-viable description with clear remaining 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 has 100% parameter descriptions, so the baseline is 3. The description adds no parameter-level guidance and does not explain how ref, url, city, feed, host, json, or string relate to the gateway lookup, but the schema already documents each parameter, so no additional penalty is warranted.

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

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

The description states a specific action ('Find') and a specific resource ('public pay-per-call tool gateway (Monid)'), then enumerates returned artifacts. It is not a tautology and is distinct enough from sibling tools in domain, though it does not explicitly name any sibling to contrast against.

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 context 'Find a public pay-per-call tool gateway' implies when the tool is appropriate, but the description gives no explicit when-to-use or when-not-to-use guidance, no alternatives, and no hint about which of the seven parameters are relevant for a typical lookup. Usage is implied rather than directed.

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 state that no browser is launched, which is useful, but it does not say whether the tool makes a network request, what it returns, whether it mutates anything, or how 'can be opened' is determined. This is a significant transparency gap for a tool that may perform remote checks.

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

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

The description is one short, front-loaded sentence that states the core action and a key qualification. Every word earns its place, and there is no repetition or filler. The only downside is that its brevity leaves out important context, but that is penalized under other dimensions.

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

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

Given no output schema, no annotations, and 9 schema parameters, this description is underspecified. It does not mention what result format the agent should expect, how to choose among parameters, or how this tool relates to siblings like playwright-url-ok or fetch-status. An agent would need additional inference to call it confidently.

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

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

The schema description coverage is 100%, so the baseline is 3 even though the description itself adds no parameter-level information. The description does not help an agent decide which of the 9 optional parameters to supply, especially since several seem unrelated to URLs. The schema handles parameter documentation, but the description misses an opportunity to clarify selection.

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 action ('Check whether a URL can be opened') and adds a distinguishing behavior ('No browser is launched'). This separates it from browser-based siblings like playwright-url-ok. However, the schema contains many unrelated parameters (city, json, path, zone, query), so the overall purpose is somewhat diluted for an agent inspecting the full definition.

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

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

The phrase 'No browser is launched' implies when this tool is appropriate versus a browser-launching alternative, but it does not explicitly name sibling tools or state conditions for use. There is no clear 'use this when...' guidance, leaving the agent to infer context from the name and one negative statement.

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 that the expression is discarded, but it never explains what happens to the actual parameters, what checks are performed, or what the tool returns.

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

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

The description is short and front-loaded, but brevity does not compensate for the mismatch between the stated arithmetic purpose and the actual schema. It is concise yet still fails to communicate the tool's real function.

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 too incomplete. An agent cannot determine which parameters matter, what qualifies as a valid call, what output to expect, or how this relates to sibling tools.

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

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

Schema coverage is 100%, so the schema documents all nine parameters, but the description refers to an 'expression' that does not exist in the schema. This actively confuses parameter semantics instead of adding value beyond the schema.

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

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

The description says 'Evaluate a+b style arithmetic,' which names a verb and resource, but the schema exposes nine unrelated parameters and no arithmetic expression field. The actual behavior is not aligned with the description, so it is misleading rather than clear.

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

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

There is no guidance about when to use this tool versus sibling tools like domain-shape, normalize-url, validate-json, or geo-hint. The description does not state alternatives or provide any selection criteria.

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

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

With no annotations, the description carries the transparency burden. It discloses one useful non-obvious fact — page content is not stored — and lists the returned fields. However, it does not explain side effects, data retention, response format, or error behavior, 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 no filler. The first sentence front-loads the primary output, and the second adds a meaningful privacy note. 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?

For a tool with nine parameters, no output schema, and several closely related sibling tools, the description is too thin. It does not state the output format, which parameters are required, how the non-URL parameters relate, or when to prefer this tool over alternatives. An agent would likely need additional investigation before invoking it correctly.

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

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

The input schema provides descriptions for all nine parameters, so the baseline is 3. The tool description itself adds little beyond naming URL as the subject, and it does not help reconcile the many non-URL parameters with the stated URL-focused purpose. 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: it returns host, scheme, and HTTP status for a URL, so the core purpose is clear. It does not explicitly differentiate from close sibling 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?

No guidance is given about when to choose this tool over the many nearby URL/status tools. 'Page content is not stored' hints at a behavioral boundary but does not state conditions, exclusions, or alternatives, leaving the agent to guess about 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 does disclose a meaningful behavior: identifiers are not retained. This is valuable because no annotations are provided. However, it does not state whether the operation is read-only, what output or return values look like, whether external calls are made, or how multiple parameters are handled, leaving the tool's overall behavior under-specified.

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

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

The description is one short, front-loaded sentence with no filler. It states the core action and a key constraint efficiently, and every word contributes meaning.

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

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

With no annotations, no output schema, and nine heterogeneous optional parameters, the description is too sparse. It never explains what 'classified' means, what the output looks like, or when to select this tool over its siblings, so an agent cannot confidently predict the tool's behavior or 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 baseline is 3. The description adds no parameter-level detail, but the schema already documents each parameter and its discard behavior; the 'No identifiers retained' sentence is a general guarantee that paraphrases the schema rather than replacing it.

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 an object ('classification of this request'), so it is not a tautology. However, 'classification' is vague: it does not specify what categories are returned, what 'this request' refers to, or how this differs from sibling classification/shape tools like domain-shape or validate-json.

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

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

There is no guidance on when to use this tool versus the many sibling tools. The only additional statement, 'No identifiers are retained,' is a privacy guarantee rather than a usage condition, and no alternatives or exclusions 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 discloses that this is a pure parsing operation and explicitly disclaims WHOIS/ownership enrichment, which is useful. With no annotations present, however, it does not describe return structure, handling of invalid hostnames or trailing dots, or whether any external lookup occurs beyond the disclaimer.

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

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

A single sentence that is front-loaded with the action and target, with no filler or repetition. The brevity is concise rather than vague, and the under-specification is a completeness issue rather than a structure issue.

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

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

Despite having no output schema and no annotations, the description stops at the input transformation. It does not explain what 'labels' means structurally, how invalid input is handled, or which of the 9 optional parameters should be used. The generic 9-parameter schema makes this omission more serious.

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 documents 'host' as 'Public hostname' and marks the other parameters as discarded/ignored. The description adds no parameter-level meaning and does not explicitly point to which parameter should be populated, but it does not conflict with the schema.

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

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

States a specific transformation: 'Split a hostname into labels'. The phrase 'without WHOIS or ownership data' narrows scope and distinguishes it from ownership/WHOIS lookups, though it does not explicitly name a sibling tool.

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 conditional guidance or alternative tool is mentioned. The negative clause 'without WHOIS or ownership data' hints at a boundary, but an agent cannot tell when to choose domain-shape over normalize-url, fetch-status, or the other shape tools. This is effectively no usage 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?

The description discloses meaningful behavior: it performs a HEAD request, only works on public URLs, and returns no body content. With no annotations available, the description carries the burden, but it omits other behavioral details such as redirect handling, timeout behavior, error responses, and what exactly 'status' means.

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, which is structurally excellent. However, given the tool's 9-parameter schema and lack of output schema or annotations, the extreme brevity leaves out information that an agent needs, so it is concise rather than appropriately sized.

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

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

For a tool with 9 optional parameters, no output schema, and no annotations, the description is incomplete. It does not state what the returned status looks like, how to choose between the many parameters, what happens when non-URL parameters are supplied, or any error/redirect semantics, so an agent cannot fully anticipate the tool's behavior.

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

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

Schema description coverage is 100%, so the baseline is 3 and the schema already documents each parameter's meaning and disposal behavior. The description adds no parameter semantics beyond 'URL', and it does not reconcile the single-URL focus with the eight other accepted parameters, which creates ambiguity about how to invoke the tool correctly.

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 (HEAD), a specific resource (a public URL), and the result (status only), so an agent can grasp the core action quickly. It does not explicitly differentiate from sibling fetch/lookup tools such as web-fetch or browser-url-ok, and the broad 9-parameter schema makes it less clear what the tool actually operates on beyond the URL.

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

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

The phrase 'return status only' implies this tool is for lightweight status checks rather than content retrieval, so some usage context is present. However, there is no explicit guidance about when to prefer this over sibling tools, no exclusions, and no mention of whether non-URL parameters are valid use cases.

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

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

With no annotations, the description carries the burden of disclosing behavior. It only states that a path is discarded, with no clarification about return values, whether this is read-only, or what happens with non-Figma URLs; this is insufficient for safe and correct invocation.

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

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

The description is short, front-loaded with the main action, and does not waste words. The second sentence is terse, but it attempts to convey a behavioral constraint and is not redundant 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?

Given the lack of an output schema or annotations, a nine-parameter schema, and many sibling URL tools, this two-sentence description is incomplete. It does not explain the return value, which parameter should hold the Figma URL, or how this differs from sibling tools such as normalize-url, leaving too much to inference.

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 extra parameter details. The description adds no meaningful mapping beyond the schema, and it never connects the `url` parameter to the Figma URL, but the schema does describe each parameter 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 identifies a specific action ('Parse') and a specific resource ('a Figma file URL'), which is enough to distinguish this from generic URL tools such as normalize-url. The 'Path discarded' fragment is ambiguous, preventing a perfect 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 input type implies this tool should be used for Figma file URLs, so an agent gets some context. However, there is no explicit when-to-use guidance, no exclusions, and no pointer to sibling alternatives for other URL shapes or URL 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 present, the description carries the behavioral disclosure burden. 'No disk access' is a genuinely useful trait, making clear this is a pure syntactic check. However, it does not describe what 'safe' means, what the return value is, or whether other side effects exist. It is adequate but incomplete.

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

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

The description is extremely concise: two short sentences, both earning their place. The core action is front-loaded and the side-effect note is valuable. There is no filler or repetition.

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

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

The tool has no output schema, no annotations, and nine optional parameters, yet the description explains neither the return value nor the meaning of 'safe.' It also fails to address which parameter matters or why the other schema fields exist. 'No disk access' helps, but the overall definition leaves too much to inference.

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 is already documented. The description does not add meaning beyond the schema and only references the concept of a path. It does not help disambiguate the many unrelated optional parameters, so a baseline of 3 is appropriate.

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

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

The description states a clear verb and resource: 'Check whether a path looks safe.' The phrase 'No disk access' adds a useful boundary. However, the input schema contains many unrelated properties such as url, city, feed, host, json, zone, and query, so the description does not clarify that only path is the relevant input; this creates some ambiguity.

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

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

There is no guidance about when to use this tool versus sibling tools like browser-url-ok, wiki-title-ok, or domain-shape. 'No disk access' is a behavioral note, not a usage guideline. The description should state that this is for lexical path safety checks, not URL or hostname validation.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It reveals only the backend ('via Open-Meteo') and the output, but says nothing about external HTTP calls, latency/failures, rate limits, which inputs are actually consumed, or that most supplied strings 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 single sentence is concise, front-loaded, and contains no filler or duplicated schema information. It is leaner than the definition needs to be for a nine-parameter tool, but as a purpose statement it is efficient.

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

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

For a tool with nine optional-looking parameters, no annotations, and no output schema, this description is incomplete: it does not say which parameter to populate, which parameters are ignored, or what the returned latitude/longitude payload looks like. An agent would struggle to invoke it correctly.

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

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

Schema coverage is 100% and each parameter has its own description, so the baseline applies; the tool description adds no parameter-level meaning. It does not indicate that 'city' is the relevant input or that the other eight fields are unrelated to geocoding.

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 resolves a place to latitude and longitude using Open-Meteo, which is enough to identify the core function. However, it does not explicitly differentiate from sibling weather/timezone tools, and the bare phrase 'a place' is ambiguous against nine unrelated input fields.

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 geo-hint instead of weather-hint, timezone, or the other shape/normalization siblings, and no conditions or exclusions are given. The intended context must be inferred entirely from the tool name and 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 provided, so the description must carry the behavioral burden. The verb 'parse' signals a non-mutating local operation, but the description does not disclose what happens for malformed GitHub URLs, whether a network request is avoided, or that unrelated schema fields are ignored. Adequate for a simple parser, but with 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 sentence with no filler, front-loaded with the verb and resource. Every word earns its place.

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

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

There is no output schema, and the description never states the return shape, failure behavior, or how the nine optional parameters should be supplied. For an agent selecting among many sibling tools, this is too sparse.

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; every property has a description. However, the main description adds no parameter semantics, and with unrelated fields like city, feed, json, and zone present, it does not explicitly tell the agent that only url is relevant for GitHub owner/repo extraction.

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'), a concrete resource ('a GitHub URL'), and names the intended result ('owner and repo'). This is enough to distinguish it from sibling shape tools like figma-url-shape or domain-shape without needing alternatives 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?

There is no guidance on when to choose this tool instead of normalize-url, browser-url-ok, or the other URL/shape siblings. A 'Parse owner and repo' statement implies an obvious use case, but the absence of alternatives or conditions leaves the agent to infer 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 the full burden of behavioral disclosure. It does state that titles are discarded, but it does not mention whether the tool fetches live data, what the return value looks like, whether parameters are ignored, or how errors 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 concise: two short sentences, with the core operation front-loaded and no filler. The second sentence adds a meaningful behavioral constraint without wasting 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?

For a tool with nine optional parameters, no annotations, and no output schema, the description is too sparse. It does not explain the return format, whether arguments are needed, or how the tool obtains the HN front page, leaving important invocation details implicit.

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 is individually explained. The tool description adds no parameter-specific meaning, and it does not clarify whether any of the optional parameters are relevant to counting Hacker News stories. Baseline 3 applies because 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 states a specific verb ('Count'), a specific resource ('current Hacker News front-page stories'), and a distinguishing constraint ('Titles discarded'). It is clear about what the tool does, though it does not explicitly contrast it with sibling tools like web-fetch or fetch-status.

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

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

The description gives no guidance about when to use this tool versus alternatives, nor whether any of the nine optional parameters should be supplied. The word 'current' implies no input is needed, but this is never made explicit.

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 must carry the full burden of behavioral disclosure. It completely fails: there is no mention of side effects, output, input handling, or read-only behavior. The schema hints that several parameters are 'discarded', which conflicts with any expectation that inputs matter, but the description does not explain this.

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, but brevity is due to under-specification rather than efficient structuring. It is a single fragment that omits a verb and all operational details, so it does not earn its place as a useful tool guide.

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?

Even for a reference-list tool, the description is incomplete. It has no output schema, no annotations, and 9 optional parameters, yet says nothing about return values, when to call it, or how parameters affect the result.

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

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

Although schema description coverage is 100%, the parameter descriptions are generic and unrelated to timezone data (e.g., git ref, URL, weather hint) and include 'discarded' notes. The tool description adds no connection between these parameters and IANA zones, leaving an agent uncertain what to pass or why any parameter exists.

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 'Common IANA timezone names for clock calls' is a noun phrase without a verb. It names the resource (IANA zones) but does not state what the tool does with them (list? validate? convert?). The name 'iana-zones' plus description is close to tautological and fails to distinguish from sibling tools like timezone or utc-time.

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 over alternatives. It vaguely mentions 'for clock calls' but does not say what situation calls for it, nor does it mention any sibling tool or exclusions. An agent cannot tell whether to use iana-zones vs timezone vs utc-time.

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 full responsibility for behavioral disclosure. It does disclose that the tool fetches a public resource and returns only group counts, which is helpful, but it omits details such as how errors are handled, what counts are returned, whether the URL is constructed from host or url, and why most parameters are described as discarded.

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

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

The description is a single, direct sentence that front-loads the main purpose and the scoping word 'only.' It is efficient and not tautological, though it sacrifices essential 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?

Given nine optional parameters, no annotations, and no output schema, the description is too thin to fully guide an agent. It does not say which parameter contains the robots.txt URL or host, what 'group counts' means exactly, or what the tool returns on failure.

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

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

The input schema has 100% description coverage, so each parameter already has some semantic explanation. The tool description itself adds no parameter-level meaning and does not connect any of the nine parameters to the robots.txt fetch, so it falls at the baseline rather than above it.

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, and return style: 'Fetch a public robots.txt and return group counts only.' This gives a clear sense of what the tool does and sets it apart from generic fetch utilities. However, it does not clarify how the target robots.txt is selected from the nine optional input parameters.

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

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

There is no explicit guidance about when to use this tool versus siblings like web-fetch, fetch-status, or browser-url-ok. The phrase 'public robots.txt' implies a use case, but the description gives no exclusions, alternatives, or advice on which of the many optional parameters should be supplied.

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 but only says 'Key discarded'. It does not disclose whether the check is side-effect-free, what happens for invalid shapes, whether the key is returned or just a boolean, or whether any authentication/rate limits apply.

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 core purpose and no filler. It is concise, though the brevity comes at the cost of omitting the parameter mapping that another dimension requires.

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 far too incomplete: it fails to identify the input parameter, the accepted Jira key format, or the return contract. An agent cannot reliably invoke this tool from the provided definition.

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

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

The schema exposes nine optional string parameters, none of which is named 'key' or described as a Jira issue key; descriptions cover unrelated concepts (Git ref, URL, city, feed, host, JSON, timezone, search text). The description does not map 'key' to any schema property, so an agent cannot know 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 description uses a specific verb and resource: 'Check a Jira issue key shape' identifies the tool's core action and target, and distinguishes it from sibling shape-checkers like domain-shape or github-repo-shape. However, it leaves the accepted key pattern unstated and the 'Key discarded' phrase is ambiguous about whether the key is input or intermediate.

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 siblings such as github-repo-shape or figma-url-shape, or when to use a different validation tool. The only implied signal is the tool name, which is not enough to route an agent confidently.

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. 'Body discarded' is a useful behavioral trait, but the description does not mention response format, network side effects, redirects, or error behavior, leaving a meaningful gap.

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

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

Two short sentences front-load the purpose and the key behavioral caveat with no filler. Every phrase 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 nine-parameter tool with no output schema and no annotations, one sentence is insufficient. The description does not explain how to choose among parameters or what the returned HTTP status looks like, and the sibling set contains similar URL/status tools that could have been differentiated.

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

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

Although schema coverage is 100%, the description does not map 'public library docs URL' to any of the nine optional parameters; the closest, url, is described as 'HTTPS URL to normalize or cite' rather than a status-check target. Since none of the params is required and several are discarded after unrelated checks, an agent cannot tell which parameter actually drives the 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/resource pair: return the HTTP status of a public library docs URL, while explicitly noting the body is discarded. It distinguishes the tool by its scoped URL subject, though it does not name sibling tools like fetch-status or web-fetch.

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

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

The phrase 'for a public library docs URL' gives a clear intended context and implies the tool should not be used for arbitrary URL fetching. It stops short of explicitly naming alternatives or when-not-to-use conditions, so it does not earn a 5.

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

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

There are no annotations, so the description carries the full burden. It discloses that values are discarded, but does not say whether the operation is read-only, what it returns, whether invalid JSON causes an error, or whether nested keys are included. For a no-annotation tool this is insufficient.

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 every word contributes. It earns a high score for structure even though it is short.

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

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

With no output schema, no annotations, nine optional parameters, and no explicit input binding, the description is too sparse to reliably guide invocation. It lacks return-value shape, valid-input explanation, and how to distinguish top-level vs. nested keys, so an agent cannot confidently select and call 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?

All nine parameters have schema descriptions, so the baseline is moderate, but the description adds no mapping to those parameters. The `json` parameter is described as 'JSON text to validate; discarded after the check,' which conflicts with the count-keys purpose and could steer an agent toward validation instead. 'Values discarded' is the only helpful hint, and it does not clarify which keys count.

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

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

States a specific action ('Count') and target ('keys in a JSON object'), plus a behavioral qualifier ('Values discarded') that separates it from validate-json and shape-check siblings. The only weakness is that it never says how the JSON object is supplied, leaving some invocation ambiguity.

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

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

No guidance on when to prefer this tool or when not to use it; no alternatives are named. The description simply defines the operation, so an agent must infer use from the generic phrase 'Count keys…' rather than from explicit routing information.

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

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

With no annotations, the description must carry full behavioral disclosure. It does state that query and fragment are dropped, which is useful, but it fails to reconcile the description with the 9-parameter schema: many parameters such as ref, city, json, and zone are not mentioned, and the description does not say whether they are ignored 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 a single front-loaded sentence that states the operation, the outputs, and the dropped components with zero filler. 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 the absence of an output schema, the presence of 9 optional parameters, and a large set of sibling tools, a one-sentence description is insufficient. It does not describe the output format, explain the role of the non-URL parameters, or clarify which sibling scenarios this tool is meant 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?

The input schema has 100% parameter description coverage, so the baseline is 3. The description adds little beyond identifying `url` as the relevant input, and the use of 'query' is potentially confusing because the schema defines a `query` parameter as search text rather than a URL query string.

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

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

The description clearly states a specific action and result: 'Return origin, host, and path for a URL' and notes that query and fragment are dropped. This distinguishes it as a URL normalization/parsing tool, though it does not explicitly differentiate it from URL-related siblings such as figma-url-shape or web-fetch.

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

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

There is no guidance about when to use normalize-url versus any of the URL-related sibling tools, nor any mention of when not to use it. The only implicit hint is the tool name and the phrase 'for a URL,' which is not enough to route an agent confidently.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It reveals one important trait, that no browser is launched, but does not explain what the check actually does, whether it makes network requests, whether it is read-only, or what it returns. The schema mentions discarded inputs, but the description itself remains thin.

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

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

Two short sentences: the first states the purpose and the second adds a critical limitation. Every word earns its place, and the most important caveat is front-loaded.

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

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

Despite a complex eight-parameter schema and no output schema or annotations, the description only addresses the URL check. It does not specify the return value, how the other parameters relate to the check, or when this tool should be preferred among the many similar sibling tools. The description is too thin 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 input schema provides descriptions for all eight parameters, and the tool description adds no parameter-level meaning. With high schema coverage, the baseline of 3 is appropriate; the description's singular 'URL' focus sits awkwardly with parameters like json and city, but those are explained in the schema.

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

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

The description states a specific action, 'Check whether a URL can be opened,' and adds a key differentiator: 'No browser is launched,' which helps separate it from the sibling browser-url-ok. It is clear, though it frames the tool as URL-only while the schema accepts eight varied inputs, so it is not fully precise.

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

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

The phrase 'No browser is launched' implies this is the lightweight choice when a real browser session is undesirable, but it never names alternatives such as browser-url-ok or fetch-status, nor does it state explicit conditions for choosing this tool. The guidance is implied rather than explicit.

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

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

With no annotations, the description carries the behavioral burden. 'Query discarded' explicitly discloses that the input is not persisted, which is useful. However, it does not describe the return value, error behavior, or whether the other eight optional parameters are ignored, leaving some 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?

Two short sentences with no filler; the function is front-loaded and the behavioral note adds value without bloat. This is an appropriately sized description.

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

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

For a simple count operation the description plus fully documented schema is mostly usable: an agent can pass `query` and expect a character count. But with no output schema, no annotation, and nine optional parameters of which only one is relevant, the description does not fully clarify what is returned or that the other parameters are irrelevant.

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 maps 'search query' to the `query` parameter but adds no details about the other eight optional fields or how they relate to the tool, so it stays at the schema-covered 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 specific action ('Count characters') and identifies the resource ('a search query'), which is enough to understand the core function. It does not differentiate it from sibling count/shape tools such as memory-key-count or hn-front-count, so it stops short of a 5.

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

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

There is no guidance about when to choose this tool instead of a sibling shape checker or other count tool. No context, exclusions, or alternatives are mentioned; the agent must infer usage solely from the name and first sentence.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure, but it only describes the object as a 'short catalog.' It does not state whether the call is read-only, whether it contacts a network, what triggers success or error, or how inputs like ref, city, or json are used or discarded. It is not contradictory, but it is behaviorally nearly silent.

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

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

The description is a single sentence with no filler, which is structurally clean. However, it is so terse that it reads as a noun phrase rather than a complete tool instruction, and with nine parameters and no output schema it is under-specified rather than appropriately sized.

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

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

For a tool with no output schema, no annotations, and nine optional parameters, the description leaves essential context unresolved: what input selects a status code, what the returned catalog looks like, and what makes this different from fetch-status. It provides only the broad topic and not enough to invoke confidently.

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

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

Schema description coverage is 100%, so parameter semantics are already documented in the input schema. The main description adds no selection guidance about which parameter is needed to look up a status, but because the schema covers all nine parameters, a baseline of 3 is appropriate.

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

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

The description identifies the domain and resource—a catalog of common HTTP status codes—but never states an explicit action like 'returns' or 'lists.' It partially distinguishes status-catalog from siblings like fetch-status by implying it is a catalog rather than a fetch, but the lack of a verb leaves the intended operation inferential.

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 call this tool, which of the nine optional parameters to provide, or how it compares with siblings such as fetch-status or browser-url-ok. No exclusions or alternatives are mentioned, so an agent must guess from the name and schema.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states that the prompt is discarded and a template is returned, hinting at a read-only, stateless operation, but it does not clarify that all parameters are ignored, that the template is fixed, or what the template contains. This leaves key behavioral traits undisclosed.

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

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

The description is compact and front-loaded, stating the purpose in the first sentence and adding a behavioral note in the second. It is concise, but 'Prompt discarded' is ambiguous and could be phrased more clearly, preventing a perfect score.

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

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

Despite the simple stated purpose, the tool has 9 optional parameters, no output schema, and no annotations. The description does not explain how parameters relate to the template, whether any arguments are needed, or what the returned template looks like, leaving an agent uncertain about correct invocation.

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

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

Schema description coverage is 100%, so the input schema already documents every parameter meaning. The tool description adds no parameter-level detail beyond the 'prompt discarded' note, which does not meaningfully enhance parameter understanding. Baseline 3 applies.

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

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

The description clearly states the action ('Return') and the resource ('a three-step thinking template'), making the primary purpose apparent. However, it does not explain what the template is for or how it relates to the tool's name, so it falls short of fully distinguishing the use case.

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

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

No guidance is provided on when to use this tool or when to prefer another. The only context is 'Prompt discarded,' which addresses behavior rather than usage context, and no alternatives or exclusions 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It states the primary behavior (returning current time) but does not mention output format, error handling for invalid timezone names, or whether the operation is read-only. For a tool with no annotation support, this is a notable gap in transparency.

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

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

The description is a single concise sentence with no filler. It front-loads the core purpose ('Current time') and does not waste tokens. This is an appropriately sized description 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?

The definition is incomplete because an agent cannot determine how to provide the timezone input given the schema mismatch. There is no output schema, no annotations, and no mention of return format or failure behavior. The description alone does not provide enough context to invoke the tool correctly.

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

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

The description refers to a 'named IANA timezone', but the input schema contains no timezone parameter; instead it lists unrelated fields such as ref, url, city, feed, host, json, and path. With additionalProperties set to false, the tool cannot accept the timezone the description implies. The description adds no useful parameter guidance and is actively misleading.

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

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

The description clearly states that the tool returns the current time for a named IANA timezone, which is a specific and identifiable purpose. It conceptually distinguishes from siblings like utc-time and iana-zones, though it does not name them explicitly. The lack of an explicit verb (e.g., 'returns') slightly reduces precision but the meaning 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 implies usage: use this tool when you need the current time in a specific IANA timezone. However, it provides no explicit guidance on when not to use it, nor does it reference alternative tools such as utc-time or iana-zones. The usage context is implied rather than directly stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says the current UTC timestamp is returned, but it does not mention that all input parameters appear to be discarded, that the operation is side-effect-free, or how the timestamp is formatted.

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 with no wasted words, but it is under-specified given the complex and mismatched schema. It is a single phrase rather than a structured explanation, which limits its usefulness.

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

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

For a tool with seven unrelated optional parameters and no output schema, a one-line description is not complete. It fails to clarify whether parameters are ignored, what format the timestamp takes, or how this tool relates to sibling time-related tools.

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

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

The input schema provides descriptions for all seven parameters, so schema coverage is high and the description does not need to restate them. However, the description adds no information about why a UTC timestamp tool accepts unrelated parameters like ref, city, json, or path, leaving their relevance unclear.

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

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

The description states that the tool returns the current UTC timestamp, which is a clear and specific purpose. However, it does not explicitly differentiate this from the sibling 'timezone' tool, so some ambiguity remains.

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 timezone or iana-zones. The description does not mention prerequisites, exclusions, or preferred contexts, leaving the agent to infer usage.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose one important trait: 'The body is discarded,' which signals non-persistence. However, it does not state what happens on success or failure, whether a boolean/result is returned, or any 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?

The description is concise and front-loaded: the validation purpose comes first, followed by the discard behavior. It wastes no words, though the term 'body' is slightly ambiguous against the actual parameter names.

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

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

This is a 9-parameter tool with no output schema and no annotations, so the description needs to provide substantial context. It fails to explain which parameter is the JSON body, why the other parameters exist, what the tool returns, or how the agent should interpret the result. The definition is too thin for confident invocation.

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

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

Schema description coverage is 100%, so the input schema already documents every parameter, including 'JSON text to validate; discarded after the check.' The description adds no parameter-level meaning and does not clarify which parameter corresponds to 'body,' but the schema compensates for most of that gap.

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

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

The description states a specific action ('Check whether') and a clear resource ('a body is valid JSON'), which distinguishes it from the sibling shape-checking tools like domain-shape or wiki-title-ok. It does not explicitly differentiate from sibling tools, but the core purpose 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?

There is no guidance about when to prefer this tool over any alternative, nor any mention of exclusions or prerequisites. The description simply states what the tool does, leaving the agent to infer usage context from the name and schema.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'via Open-Meteo' and does not explain that many of the nine schema parameters are unrelated or discarded, that the operation is stateless, or what the output looks like. The schema's parameter descriptions contribute some detail, but the description itself adds little.

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, which is good. However, for a tool that exposes nine optional parameters, it is under-specified rather than appropriately compact because it omits the selection and discard behavior that would help an agent parse the noisy 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 no annotations and no output schema, the description is not complete enough. It fails to address why the schema contains ref, url, feed, host, json, path, zone, and query, which could mislead an agent into passing irrelevant parameters. The 100% schema coverage helps parameter semantics but does not fill the broader contextual gap.

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

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

Schema description coverage is 100%, so the baseline applies. The description names 'city' only implicitly and does not add meaning beyond what the schema already documents for each parameter. It neither clarifies the role of the other eight parameters nor improves on the schema.

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

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

The description clearly identifies the tool's core function: returning the current temperature for a city, and it names the data source (Open-Meteo). It is not vague or tautological, but it lacks an explicit verb and does not position itself against related siblings like geo-hint, so it does not earn a 5.

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

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

There is no guidance about when to choose weather-hint over alternatives, nor any mention that only the city parameter matters. The intended use is only implied by the phrase 'for a city,' with no prerequisites, exclusions, or sibling comparisons.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It does disclose the non-obvious behavior that the body is discarded, which is helpful, but it omits any mention of error handling, network request behavior, or response format details.

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, focused sentences with the core function and the key behavioral caveat front-loaded. Every word earns its place, with no filler or repetition.

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

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

The input schema has seven parameters of unclear relationship to the described function, and there is no output schema. The description does not clarify how or whether the extra parameters affect behavior, what the response format looks like, or how to choose this tool over near-sibling tools like fetch-status. This is a meaningful gap for an agent trying to call 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?

All seven parameters already have descriptive text in the input schema, such as 'HTTPS URL to normalize or cite' and 'Git ref name; discarded after the shape check'. The description itself adds no additional parameter-level meaning, so the schema does the work and the baseline 3 applies.

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

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

The description clearly states the tool returns HTTP status and content type for a public URL, and adds the body-discarding behavior. However, it does not explicitly differentiate it from sibling tools like fetch-status or normalize-url, so it is clear but not fully distinguished.

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 use cases: public URLs and cases where only status/content type matter, not the body. It gives no explicit when-to-use versus alternatives or exclusions, leaving usage guidance only implied.

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

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

No annotations are present, so the description carries the full burden. It discloses that the title is 'discarded after the call,' which hints at privacy/statelessness, but it does not explain return values, error behavior, network dependencies, or side effects. This is insufficient 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 a single sentence and economical, but its brevity removes critical information needed for correct invocation. The sentence is clear about the action but omits input binding and behavior details, so the conciseness does not serve the agent well.

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 8 parameters, no annotations, and no output schema, a one-sentence description is grossly incomplete. The agent cannot determine what to pass, what the tool returns, or how to interpret the parameter descriptions. This is far below the minimum viable 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?

The schema lists 8 parameters, none of which is named 'title,' and the description does not connect 'title' to any of them. The parameter descriptions themselves (Git ref, city, JSON, etc.) are unrelated to the stated purpose, leaving the agent unable to determine which input to provide. The description adds no meaningful parameter guidance.

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 whether a Wikipedia title exists.' This clearly identifies the tool's resource and purpose, and distinguishes it from siblings like browser-url-ok or file-path-ok. However, the mention 'Title discarded after the call' introduces ambiguity about what the title is or how it is passed, slightly reducing clarity.

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

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

The description gives no guidance on when to use this tool instead of other validation tools (e.g., browser-url-ok, file-path-ok). There is no mention of use cases, constraints, or alternatives, so an agent cannot determine the tool's appropriate context.

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