Hostname label count

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

There are no annotations, and the description does not disclose side effects, costs, permissions, or network access. The repeated 'discarded' hints suggest the tool performs no persistent actions, but this is not explicit. The term 'pay-per-call' implies potential charges, yet no warning or clarification is given.

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 follows a straightforward structure: two short sentences that state the purpose and a caveat. It avoids unnecessary fluff and gets to the point quickly, though the brevity contributes to ambiguity in other dimensions.

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

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

Given the tool's complexity (9 optional parameters, no output schema, no annotations), the description is insufficient. It does not explain how the parameters are used together, what the expected output format is, or provide any example call. An agent would struggle to construct a meaningful request without additional context.

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

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

While the schema descriptions cover all 9 parameters, they are inconsistent and misleading. For example, 'City name for a public weather hint; discarded after the call' suggests the parameter is used as a hint but then discarded, and 'Search text; discarded after the length check' implies it is only used for validation. The descriptions do not clarify how these parameters relate to the tool's core function of finding a gateway, leaving the actual semantics 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 the tool's primary function: 'Find a public pay-per-call tool gateway for a task such as weather, search, scrape, or voice.' This provides a clear verb (find) and resource (gateway), but the phrase 'Task text discarded' is ambiguous and could confuse the reader about what input is actually used.

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

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

No guidance is provided on when to use this tool versus alternatives. The sibling-tools list includes many related tools (e.g., weather-hint, search-query-len, validate-json), but the description does not mention any of them or explain how this index differs. Thus, an agent cannot determine when to prefer this tool over others.

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 no browser is launched, but it does not explain what 'can be opened' means (e.g., HTTP request, URL syntax check, DNS resolution), what the return value is, or what side effects occur. Several parameters are marked as discarded, but the tool-level behavior remains opaque.

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

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

The description is very concise and front-loaded, with no filler or redundant sentences. It clearly states the primary action and an important constraint, though it sacrifices necessary detail for brevity.

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 parameters, no output schema, and no annotations, this two-sentence description is far too incomplete. It does not explain how parameters relate to the action, what result to expect, or how to handle the many seemingly decoy fields.

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 each parameter has a schema description, most are irrelevant to checking whether a URL can be opened (city, feed, json, path, zone, query). The core 'url' parameter description says 'normalize or cite,' which conflicts with the tool's stated purpose, leaving an agent without reliable guidance on 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 states a clear action and object: 'Check whether a URL can be opened.' However, the parameter list includes many unrelated fields (city, feed, json, path, zone) and the 'url' parameter description says 'normalize or cite' rather than 'check openable,' which muddies the intended purpose.

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

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

The only usage guidance is 'No browser is launched,' which distinguishes it from browser-based tools but does not explain when to use this tool versus siblings like playwright-url-ok or fetch-status. There is no explicit recommended scenario or alternative.

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?

'Expression discarded' discloses one behavioral trait, but since no annotations are provided, the description carries the full transparency burden. It does not reveal that the tool effectively ignores all schema inputs (beyond shape checks), nor that the described arithmetic evaluation has no corresponding input. The overall no-op behavior is only partially and confusingly disclosed.

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

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

The description is two short sentences with the primary action front-loaded and 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?

Despite full schema parameter coverage, the description creates a schema-vs-purpose mismatch that leaves the tool's actual function ambiguous. An agent cannot determine what inputs matter, what the tool returns (no output schema), or why it exists alongside overlapping siblings — the description is too thin to resolve these 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?

Schema description coverage is 100%, so the baseline is 3, but the description actively undermines parameter understanding by referencing an 'expression' input that does not exist in the schema. It adds no mapping between the stated purpose and the 9 actual parameters, leaving the agent unable to know which parameter would carry an expression or why the others exist.

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 verb 'Evaluate' with object 'a+b style arithmetic' states a clear intent in isolation, but the schema contains no arithmetic-expression parameter — the 9 parameters are ref, url, city, feed, host, json, path, zone, and query. This mismatch makes the actual purpose confusing and misleading rather than informative.

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

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

The description gives no guidance on when to use this tool versus any of its 27 siblings, several of which directly map to its parameters (normalize-url for url, weather-hint for city, timezone/iana-zones for zone, validate-json for json, search-query-len for query, file-path-ok for path). It never states when to choose calc-eval or when to avoid 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 provided, the description carries the full burden. It discloses one behavior ('Page content is not stored') but omits critical aspects such as whether network requests are made, if it is read-only, error handling, or any side effects. This is insufficient for a tool that likely performs HTTP requests.

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 sentences with no fluff. The purpose is front-loaded in the first sentence, and the behavioral note in the second adds value without redundancy.

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

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

The description is incomplete for a tool with 9 parameters and no output schema. It does not explain how the many seemingly unrelated parameters (city, zone, json) relate to the core URL function, nor does it describe the exact output structure or error behavior. An agent would lack critical information to call this correctly.

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

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

Schema description coverage is 100%, so each parameter is already documented. The tool description adds no additional meaning beyond the schema, but does not contradict it. The baseline of 3 applies since the schema handles parameter explanation.

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 ('Return') and the exact data points (host, scheme, HTTP status) for a URL, which clearly distinguishes it from siblings like normalize-url or web-fetch. The additional note that page content is not stored further differentiates it from tools that fetch and retain content.

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

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

There is no explicit guidance on when to use this tool versus alternatives like fetch-status or browser-url-ok. The description does not mention conditions for selection, exclusions, or context where a sibling would be more appropriate.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'No identifiers are retained,' which is a privacy note, but doesn't explain side effects, whether network calls are made, or what happens to the inputs. For a tool with 9 diverse parameters, 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?

The description is a single concise sentence with no filler words. It is efficient, though it sacrifices informativeness for brevity.

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 parameters, no output schema, and no annotations, the description is far too sparse. It doesn't explain what classification means, what the return value is, or how the inputs are used. An agent would have no idea how to correctly invoke or interpret this 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 description coverage is 100%, so the schema already documents all 9 parameters with individual descriptions. The tool description adds no additional meaning beyond the schema, meeting the baseline for high coverage.

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

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

The description 'Show how this request is classified' is vague and doesn't specify what kind of classification, what inputs it accepts, or what the output is. It fails to distinguish from sibling tools like validate-json or domain-shape, and the name 'compatibility' doesn't clarify the purpose.

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

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

There is no guidance on when to use this tool versus alternatives. The description provides no context about typical use cases, prerequisites, or when to prefer another sibling 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?

No annotations are provided, so the description carries the burden. It mentions the absence of WHOIS/ownership data but does not disclose side effects, data flow, or that unrelated parameters 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?

One clear sentence with no redundant verbiage. The negative clause is brief and useful, though it lacks a structured breakdown.

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?

No output schema and no description of return format, which parameters are used, or edge cases. For a tool with 9 parameters, this leaves too much unspecified.

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

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

Schema description coverage is 100% and each parameter has some description, so baseline is 3. The main description adds no parameter mapping, but the schema already provides per-parameter text.

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 ('Split a hostname into labels') and the resource. It differentiates from ownership/WHOIS queries, though it doesn't explicitly name the target parameter or distinguish from the sibling 'host-labels' 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?

Provides no guidance on when to choose this over sibling tools like host-labels or normalize-url. The only caveat is a negative statement about WHOIS/ownership data, which is not actionable as a usage rule.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It states that a HEAD request is made and only the status is returned, which is clear. However, it omits that the tool accepts many other parameters and discards them after validation, which could surprise the agent. It also does not mention that the operation is read-only (though HEAD implies this) or any potential rate limits or side effects.

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

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

The description is a single, concise sentence that is front-loaded with the main action. It is efficient and easy to parse. However, it is so sparse that it fails to convey the tool's broader scope, which is a completeness issue rather than a conciseness problem. The brevity itself is appropriate.

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

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

The tool has 9 optional parameters, no output schema, and 26 sibling tools. The description only covers the URL use case and gives no indication that the tool handles many other input types, nor does it explain the status semantics or provide any usage context. This is severely incomplete for an agent to use the tool correctly across its full parameter set.

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

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

Schema description coverage is 100% and each parameter has a descriptive explanation (e.g., 'discarded after the shape check'). The tool description adds no parameter information, but since the schema already covers all parameters, the baseline of 3 applies. The description 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?

The description states a specific verb (HEAD) and resource (public URL) with a clear outcome (return status only). However, the input schema contains 9 parameters covering many different resources (city, feed, JSON, timezone, etc.), which the description does not mention at all. This narrows the tool's apparent purpose to a single use case and does not differentiate it from sibling tools like browser-url-ok or normalize-url, which also handle URLs.

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

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

The description provides no guidance on when to use this tool versus the many sibling tools. It does not mention alternatives, exclusions, or any context for selection. With 26 sibling tools listed, the absence of any routing information is a critical gap.

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. The only behavioral detail is 'Path discarded', implying the path component is ignored. It does not disclose what the tool returns, side effects, or how it treats the other eight parameters. This is minimal disclosure for a tool with such a broad 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 very short (one sentence), which is concise, but it is under-specified. It lacks any structure to convey the tool's multi-parameter nature or its output. The single statement 'Path discarded' is ambiguous and not front-loaded with essential context.

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

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

With 9 parameters, no output schema, and no annotations, this description is grossly incomplete. It does not explain the tool's overall function, what it validates, what it returns, or how the parameters relate. An agent cannot reliably call this tool based on the description alone.

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

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

Schema description coverage is 100%, so each parameter already has a description, yielding a baseline of 3. However, the tool description only mentions Figma URLs while the schema includes unrelated params like city and feed, which could mislead an agent. The description adds no meaning beyond the schema and actually conflicts with the schema's broader scope.

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 ('Parse') and resource ('Figma file URL'), which gives a clear action and object. However, it does not distinguish this tool from many URL-related siblings like normalize-url or browser-url-ok, and the schema shows 9 unrelated parameters (city, feed, json, etc.) that the description ignores, making the actual scope ambiguous.

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

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

There is no mention of when to use this tool versus alternatives. It does not name any sibling tool, give criteria for selection, or state exclusions. An agent has no guidance on choosing this over other URL shape checkers.

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 'No disk access,' which is a useful safety trait, but it does not disclose what 'safe' means, whether it returns a boolean or a status, error handling, or any side effects. The description is too minimal to adequately inform the agent about the tool's behavior beyond the one statement.

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—a single sentence with no fluff. It front-loads the primary action and the key safety constraint. However, the brevity borders on under-specification, but for conciseness itself, it is well-structured and wastes no words.

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

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

The tool has nine parameters and no output schema, yet the description covers only one (path) and provides no information about return values, error conditions, or the purpose of the other parameters. It is severely incomplete for an agent to understand the full scope of the tool, especially given the mismatched schema. The description needs to explain why the other parameters exist and what the tool does with them.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. However, the description adds no additional meaning to any parameter; it only repeats the 'path' and 'no disk access' details already present in the schema. It ignores the other parameters entirely, failing to clarify why they exist or how they relate to the tool's purpose. The description adds no value beyond the schema, so it falls below the baseline of 3.

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

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

The description states a specific verb ('Check') and resource ('path') with a safety constraint ('looks safe', 'no disk access'), which is clear at a high level. However, it fails to acknowledge the other eight parameters in the schema (ref, url, city, feed, host, json, zone, query), creating ambiguity about the tool's actual scope. The name 'file-path-ok' implies focus on file paths, but the schema suggests a broader validation role, so the purpose is not fully 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 on when to use this tool versus alternatives. It does not mention any sibling tools (e.g., browser-url-ok, domain-shape) or conditions for selection. The description only states what it does without context on when it is appropriate, leaving the agent without decision criteria.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only adds 'via Open-Meteo,' which signals an external dependency, but omits error behavior, rate limits, return format, and how the tool behaves with the many non-geocoding parameters. The schema's own notes (e.g., 'discarded after the call', 'no disk access') are not in the description, leaving behavioral context 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?

A single, efficient sentence with zero filler and the core fact (lat/long via Open-Meteo) stated up front. The brevity is a strength, though it veers into under-specification rather than deliberate conciseness.

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

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

For a tool with 9 parameters, no output schema, and no annotations, a one-line description is grossly inadequate. It neither explains how the parameters relate to the stated purpose nor describes the return value or failure modes, leaving an agent unable to confidently select or invoke it.

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

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

Schema description coverage is 100%, which normally sets a baseline of 3. However, the description does not map any of the 9 parameters to its stated purpose, and it actively conflicts with them: a geocoding tool would not need 'url', 'json', or 'path'. The description fails to clarify which parameter (city? query?) actually triggers the lat/long lookup, so it adds no semantic value beyond the schema and creates ambiguity.

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

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

The description states a verb (provide lat/long) and resource (a place via Open-Meteo), but it conflicts with the tool's actual parameter surface. The schema exposes 9 parameters (ref, url, feed, host, json, path, zone) that have nothing to do with geocoding, and only 'city' and 'query' plausibly relate to a place lookup. An agent reading the schema cannot reconcile the stated geocoding purpose with the majority of parameters, so the stated purpose is misleading rather than clarifying.

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 its siblings. Siblings include weather-hint, timezone, iana-zones, and normalize-url, yet the description gives no exclusions or conditions, leaving an agent to guess which tool handles geocoding vs. weather vs. timezone lookups.

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

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

No annotations are provided, so the description carries the full burden for side effects and access behavior. It only says 'Parse', which suggests a local read-only operation, but it never confirms that no network request is made, whether auth is needed, or what happens for malformed URLs. The parameter descriptions about 'discarded' hint at side-effect-free behavior, but the tool description itself does not disclose 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 a single, tight sentence beginning with an action verb and no filler. It is well structured and front-loaded.

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

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

Given 9 optional parameters, no output schema, and no annotations, the one-sentence description is not enough to determine the required inputs or return format. It does not specify which parameter(s) to supply, how the returned owner and repo are represented, or whether enterprise GitHub URLs are supported. This leaves significant gaps for an agent to resolve.

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

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

Although every parameter has a schema description, those descriptions are largely unrelated to the stated purpose: city, feed, json, path, zone, and query appear to belong to other tools and are labeled as discarded. Only url is plausibly relevant, but its schema description says 'HTTPS URL to normalize or cite' rather than 'GitHub URL to parse for owner/repo'. The tool description also fails to indicate which of the 9 optional parameters are actually used.

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

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

The description uses a specific verb ('Parse') and a clear resource ('owner and repo from a GitHub URL'), which distinguishes it from sibling URL tools like normalize-url or domain-shape. It is immediately understandable what the tool is for, though it does not state the output shape.

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

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

It provides only an implied usage scenario: when a GitHub URL is at hand and owner/repo need extraction. It does not explicitly state when to prefer this over related tools such as normalize-url or jira-key-shape, nor any exclusions. Thus the guidance is present but implicit.

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

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

With no annotations provided, the description must carry the full behavioral burden. It only mentions 'Titles discarded' as a minor behavioral note, but does not disclose whether the tool is read-only, what it returns (e.g., an integer count, a JSON object), any rate limits, or whether it makes network calls. The lack of any such detail is a significant gap for a tool with no 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 with no wasted words, and the core purpose is front-loaded. However, it is so terse that it omits crucial invocation details, making it borderline under-specified rather than genuinely concise. It earns a 4 for efficiency but not a 5 because the brevity sacrifices necessary context.

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

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

This is a tool with 9 parameters, no output schema, and no annotations, yet the description provides only a one-line purpose and a cryptic note about titles. An agent cannot determine how to construct a valid call, what the return format is, or what side effects (if any) occur. The description is fundamentally inadequate for a tool of this 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?

Although the input schema descriptions cover all 9 parameters, they are generic and unrelated to the tool's stated purpose (e.g., 'ref', 'city', 'json' all being 'discarded' or 'checked'). The tool description does not clarify which parameter(s) an agent should provide to trigger the count of Hacker News stories, leaving the mapping between purpose and parameters entirely opaque. The description adds no value beyond the schema, and the schema itself is unhelpful for this 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, specific action: 'Count current Hacker News front-page stories.' This is a unique purpose not covered by any sibling tool, which are mostly URL/format validators. The phrase 'Titles discarded' adds a distinctive detail that further separates it from similar counting tools.

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

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

The description gives no guidance on when to use this tool versus any of the siblings, nor does it mention any prerequisites, exclusions, or alternative tools. An agent has no information about the intended context (e.g., whether it should be used for validation checks or content queries).

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 mentions no side effects, return values, exceptions, or operational constraints. The phrase gives no indication of what happens when the tool is invoked.

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

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

The description is extremely short, but it is not appropriately sized; it is under-specified. It lacks any sentence structure or front-loaded key information. While brevity is good, this is a bare noun phrase that fails to convey essential 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 parameters, no annotations, and no output schema, the description is completely inadequate. It does not explain the tool's purpose, which parameters to use, or what the result represents. An agent cannot determine how to invoke this tool correctly.

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

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

Although the schema has 100% description coverage, the parameter descriptions are clearly generic and copied from other tools (e.g., 'weather hint', 'RSS/Atom', 'normalize or cite'), none of which relate to host labels. The tool description does not clarify which parameters are relevant or how they contribute to the output, making the schema descriptions misleading for this tool.

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

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

The description 'Hostname label count' is a noun phrase that fails to specify an action or resource. It does not say whether the tool counts labels in a hostname, counts hostname labels in a dataset, or something else. It is essentially a title, not a functional description, and offers no differentiation from sibling 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 alternatives like 'domain-shape' or 'normalize-url'. The description provides no context, prerequisites, or exclusions, leaving the agent to guess entirely.

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 bears the full burden of disclosing behavior, and it carries none of it: it doesn't say the operation is a read, returns a static list, has no side effects, or what shape the response takes. The fact that parameters are 'discarded after the shape check' appears only in the schema, not in the description.

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

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

A single eight-word sentence is certainly short and front-loaded, but conciseness only pays off when the remaining text is complete. The brevity here is under-specification rather than economy, so it scores only as structurally fine.

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

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

For a tool with nine parameters, no output schema, and no annotations, a nine-word description is severely incomplete. An agent has no idea what the tool returns, which parameters matter, whether it is destructive, or how it relates to the many sibling hint tools; a glaring mismatch between the timezone-focused description and the kitchen-sink schema compounds this.

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 regardless of the description's silence on parameters. The description at most relates the zone parameter to IANA names; it adds nothing about the other eight unrelated parameters or how they interact with the tool's 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 'Common IANA timezone names for clock calls' names a resource but no verb — it is a noun phrase, not an action statement. It hints that the tool offers a curated list of zones for clock/time calls, which loosely separates it from timezone and utc-time, but the agent cannot tell whether the tool validates, lists, or hints. This is vague purpose, above a tautology but below a clear 'return a list of...' statement.

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

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

There is no guidance on when to use this tool versus the sibling timezone or utc-time tools, nor any mention of when not to invoke it. The phrase 'for clock calls' implies a context but never names which sibling it feeds or what conditions select 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 provided, the description must carry the full burden of behavioral disclosure. It implies a network fetch but does not state that the operation is read-only, that most parameters are ignored, or that the result is limited to a count. The schema notes that parameters are 'discarded after the shape check', but the description itself adds no such context.

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 fluff, but it is under-specified rather than efficiently informative. It is too brief to convey the necessary context for a tool with 9 parameters and no output 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?

This tool has 9 parameters, no output schema, and no annotations. The one-sentence description is completely inadequate to explain which parameter to use, what 'group counts' means, or how the tool behaves. An agent cannot reliably determine how 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?

Although the schema provides 100% coverage with descriptions for all 9 parameters, the tool description does not clarify which parameter holds the robots.txt URL. The 'url' parameter is described as 'HTTPS URL to normalize or cite', not as the target of the fetch, so the mapping between the description and the schema is ambiguous. The description adds no extra meaning 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 states a specific verb and resource ('Fetch a public robots.txt') and a specific output ('return group counts only'), so the core purpose is identifiable. However, it does not distinguish this from sibling tools like web-fetch or fetch-status, and the 9 unrelated parameters (ref, city, json, etc.) make it unclear how the purpose maps to the inputs, lowering clarity.

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

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

No guidance is given on when to use this tool versus alternatives. It does not mention that it is a shape-check or validation tool, nor does it suggest using it specifically for robots.txt inspection over other fetch tools. The absence of any contextual or alternative references leaves usage 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, the description carries the full burden of behavioral disclosure. It only mentions that the key is discarded, which is a minor detail about data handling. It does not explain what 'shape check' means, what a valid Jira key looks like, whether it returns a boolean, throws an error, or what happens on invalid input. The description is too thin to convey the tool's actual 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 a single short sentence, which is concise and front-loaded. However, it omits critical information about the tool's multi-input schema, so it sacrifices completeness for brevity. Still, the structure is clean and easy to parse, earning a 4 for conciseness.

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

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

The tool is complex (9 optional parameters, no output schema, no annotations), yet the description provides almost no context. It fails to reconcile the Jira-key purpose with the diverse schema fields, leaving an agent unable to determine what input to provide for a Jira key check or how the other fields relate. The description is severely incomplete for the tool's actual scope.

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 descriptions cover 100% of parameters, each with a brief note (e.g., 'Git ref name; discarded after the shape check'). The tool description itself adds no parameter-level meaning, so it relies entirely on the schema. Since schema coverage is high, the baseline of 3 is appropriate; the description does not enhance understanding 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 clearly states a specific verb ('Check') and a specific resource ('Jira issue key shape'), which distinguishes it from sibling shape-check tools like 'domain-shape' or 'github-repo-shape'. However, the input schema lists 9 unrelated fields (city, feed, host, json, etc.) with no apparent connection to Jira keys, so the purpose is not fully aligned with the tool's actual interface, creating ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any conditions, prerequisites, or exclusions, nor does it reference any sibling tools. An agent would have to infer from the name and sibling list that this is for Jira key format validation, but no explicit usage direction is given.

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

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

The description states that the body is discarded, which is useful. However, with no annotations, it does not disclose output format, error behavior, or explicitly confirm read-only behavior beyond the implied HTTP status check.

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

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

Two short sentences, both necessary and free of redundancy. The description is tightly scoped and easy 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?

With 9 optional parameters, no output schema, and no annotations, the description is too sparse. It leaves unclear which inputs are actually needed, what the return value looks like, and what failure modes may occur.

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

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

Schema descriptions cover all 9 parameters, so the baseline is 3. The top-level description only identifies URL and does not clarify why city, feed, query, and others are present; the url schema description ('normalize or cite') also conflicts with the stated HTTP-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?

Identifies the resource (public library docs URL) and result (HTTP status), but uses a noun phrase rather than an explicit verb, and 'public library docs' is ambiguous. With siblings like fetch-status and web-fetch, it needs more precision to distinguish the exact purpose.

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

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

No guidance about when to use this tool versus fetch-status, browser-url-ok, or web-fetch. It provides no use-case context or exclusion criteria.

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

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

No annotations exist, so the description carries the burden. It implies a read-only operation but does not explicitly state side effects or lack thereof. The phrase 'Values discarded' hints at output behavior, not side effects.

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

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

The description is a single concise sentence with no unnecessary words, perfectly 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?

The description is severely under-specified. With 9 optional parameters, it does not identify the required input, expected output, or edge cases. This makes the tool difficult to use correctly without external knowledge.

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?

Parameter descriptions are generic and mismatched with the tool's purpose. The 'json' parameter mentions 'validate' rather than 'count keys', and multiple parameters (ref, url, city) appear irrelevant to counting keys. It is unclear which parameter is 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 clearly states the action (count keys) and the object (JSON object). However, it does not specify which parameter contains the JSON, leaving slight ambiguity in context.

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

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

No guidance is provided on when to use this tool versus alternatives like validate-json or other sibling tools. The description does not mention any distinguishing 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 full burden of behavioral disclosure. It only states that query and fragment are dropped, but says nothing about error handling, response format, or how the nine input parameters relate to the operation. The presence of unrelated parameters (city, json, zone) is unexplained, creating confusion about actual 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 a single efficient sentence that front-loads the core action and the dropping behavior. It earns its place, though it sacrifices completeness for brevity. No fluff 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?

For a tool with nine parameters, no annotations, and no output schema, the description is severely inadequate. It does not explain return structure, which parameters are used, error behavior, or how to distinguish it from similar tools. An agent cannot reliably decide when to call it or interpret its results.

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% (every parameter has a description), so the baseline is 3. However, the tool description adds nothing about parameters and fails to clarify that only 'url' is relevant; it does not even mention the other parameters or that they are ignored. The mismatch between the description and the schema actively undermines correct usage.

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 ('Return'), a specific resource ('origin, host, and path for a URL'), and a precise behavior ('Query and fragment are dropped'). It is unambiguous and distinguishes the tool's core function from generic URL helpers, though it does not name a sibling alternative.

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

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

The description gives no guidance on when to use this tool versus the many URL-related siblings (e.g., browser-url-ok, github-repo-shape). No context, prerequisites, or exclusions are provided, leaving the agent to guess based on name alone.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states 'No browser is launched,' which is a negative constraint, but it does not explain whether the tool performs a network request, validates URL format, or simply checks accessibility. It also does not mention that many parameters are 'discarded' or that it has a broader scope implied by the schema, leaving significant behavioral ambiguity.

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 two short sentences. The primary purpose is front-loaded in the first sentence, and the second adds a key distinguishing detail. There is no redundant or filler content, making it efficiently structured.

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

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

Given the tool has 9 parameters, no annotations, and no output schema, the description is severely incomplete. It does not explain how the tool behaves with the diverse set of parameters (many of which are unrelated to URLs, like city, JSON, path), nor does it describe the return value or any side effects. An agent cannot determine proper usage or expected outcomes from this description alone.

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

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

The schema provides 100% coverage, with each parameter having a description, so the baseline is 3. The tool description adds no additional meaning about parameters; it does not explain how they relate to the tool's core function or which are relevant. Since the schema already documents the parameters, the description does not need to compensate, but it also does not enrich 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 clear verb and resource: 'Check whether a URL can be opened.' It also distinguishes from the sibling 'browser-url-ok' by explicitly saying 'No browser is launched,' making the purpose specific and differentiating.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives. The only hint is 'No browser is launched,' which implies a use case but does not state when to choose this over other tools like 'normalize-url' or 'fetch-status.' No exclusions or alternative conditions 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?

No annotations are provided, so the description carries the full disclosure burden. It does disclose one useful behavioral fact: 'Query discarded' indicates the input is not retained, which is privacy-relevant. However, it omits other behavioral aspects such as what the tool returns (a number is implied but not stated), whether there are any side effects, and why the other 8 parameters exist if only query is counted.

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

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

Two sentences with zero waste. The purpose is front-loaded in the first sentence, and the behavioral note about discarding follows immediately. 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 tool has 9 parameters, no output schema, and no annotations, the description is thin. It doesn't clarify whether the other 8 parameters are relevant to the count, what the return format looks like, or how an agent should pick which parameter to populate. For a tool with this much schema surface area, the minimal two-sentence description leaves gaps, though the 100% schema coverage partially compensates.

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

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

Schema description coverage is 100%, so every parameter is already documented in the input schema, which is the baseline of 3. The description itself adds only marginal parameter meaning ('Query discarded' reinforces the schema's 'discarded after the length check' note) but doesn't explain the relationship between the 9 parameters or which one actually drives the count. The schema already does the heavy lifting.

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

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

The description states a specific verb (count) and resource (characters in a search query), making the core purpose clear. It is distinguishable from count-type siblings like memory-key-count and hn-front-count by the 'search query' resource, though it doesn't explicitly name those alternatives. However, with 9 parameters in the schema, the description only references 'query', leaving the role of the other 8 parameters unexplained at the purpose level.

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

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

No guidance is provided on when to use this tool versus the 28 siblings. It doesn't state any exclusions, prerequisites, or conditions that would route an agent here instead of to similar counting tools like memory-key-count or hn-front-count. The agent must infer usage solely from the name and short 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?

With no annotations, the description should disclose side effects and output behavior. It only states the content is a catalog; it does not mention that parameters are ignored or whether any network/disk access occurs.

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

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

The description is a single short sentence with no redundant words, making it maximally 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?

The description is too sparse for the unusual 9-parameter schema; it does not clarify why parameters are accepted, what output format to expect, or that no arguments are needed to obtain the catalog.

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 descriptions cover 100% of parameters, so the baseline applies. The tool description adds no parameter explanation, but the schema does indicate most values are discarded, which is some semantic signal.

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 as a catalog of common HTTP status codes. It lacks an explicit verb but the noun phrase and title are 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?

No guidance is given about when to use this tool instead of sibling tools like fetch-status or web-fetch, nor any mention of expected usage context.

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

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

With no annotations, the description carries the full burden of disclosing behavior. It only says 'Prompt discarded,' which is cryptic and possibly misleading—it could imply the tool ignores all input, yet the schema defines parameters that are described as being used for checks. There is no statement about network access, side effects, or what happens to the parameters. This is a serious 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 only one sentence, which is concise, but it is severely under-specified. It omits critical information about the template's content and the role of the parameters. The brevity is not an asset here; it is a symptom of incompleteness. A well-structured description would at least hint at the tool's purpose and usage context.

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

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

For a tool with 9 optional parameters, no output schema, and no annotations, this description is entirely inadequate. An agent has no idea what the template looks like, how the parameters affect it (if at all), or what the return value is. The tool appears to be a simple utility, but the description fails to give even a minimal mental model for correct invocation.

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

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

Schema description coverage is 100%, so each parameter has a description in the schema, which already states they are 'discarded after' certain checks. The tool description adds no new meaning to the parameters—it does not clarify how the template might relate to any of them. Since the schema covers the parameters adequately, the baseline of 3 is appropriate, but the description does not add value beyond 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 the tool returns a 'three-step thinking template,' which names a clear verb and resource, but it does not explain what the template is for, what it contains, or how it differs from any sibling tool. The phrase 'Prompt discarded' is ambiguous, leaving the agent uncertain whether the tool processes any input at all. This is more than a tautology but far from a helpful 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?

No guidance is given on when to use this tool versus any of the 29 siblings. There is no mention of intended scenarios, prerequisites, or alternatives. An agent cannot infer whether this is a fallback for other tools or a specific utility. The description provides no usage context whatsoever.

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 only says 'Current time in a named IANA timezone,' without explaining network access, error behavior for invalid zones, return format, or side effects. The sparse text leaves critical behavior undocumented for a tool that likely requires external calls.

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

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

The description is concise (one sentence) and front-loaded with the main purpose, which is good. However, given the tool has 9 parameters and multiple seemingly unrelated fields, the brevity is excessive and fails to provide a structured overview. It is appropriately sized for a trivial tool but not for one with this schema.

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

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

The tool has 9 optional parameters, no output schema, and no annotations, yet the description is a single sentence that ignores most of them. The presence of parameters like 'ref', 'url', 'city', 'feed', 'host', 'json', 'path', and 'query' is unexplained and seems incongruent with a timezone lookup. An agent cannot determine what these are for or how they relate to the stated purpose, making the description severely 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 coverage is 100%, so every parameter is documented in the input schema. The description adds no additional parameter context; it doesn't even mention the 'zone' parameter. Per the baseline rule for high schema coverage, a score of 3 is appropriate because the schema carries the semantic load.

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: 'Current time in a named IANA timezone.' It is clear what the tool does, but it does not differentiate from sibling tools like utc-time or iana-zones. The purpose is understandable but not unique among the sibling set.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention utc-time for UTC time or iana-zones for zone lists, nor does it state any conditions for selection. An agent would have no basis to choose this over its siblings.

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

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

No annotations are provided, so the description must disclose all behavioral aspects. It only says 'current UTC timestamp' and gives no indication of what the 9 parameters do, why they are accepted, or that they are effectively ignored for the primary function. 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 extremely concise (one sentence), but it under-specifies by ignoring the parameter list. It is not a matter of being concise; it is a matter of being incomplete. The sentence earns its place but fails to address the schema's complexity.

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

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

With 9 parameters, no annotations, and no output schema, the description is wholly inadequate. An agent has no way to determine whether any parameter is required, how to interpret the response, or why the parameters are listed. This is a basic timestamp tool with an inexplicably complex schema, and the description provides none of the necessary context.

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

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

Although the schema descriptions cover all parameters, they are completely disconnected from the tool's purpose. For example, 'Git ref name; discarded after the shape check' implies a git-related operation, not UTC time. The description adds no explanation of how these parameters affect the timestamp output, leaving the agent confused about why they exist.

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 purpose: returning the current UTC timestamp. It is a specific verb-resource combination and distinct from siblings like timezone. However, it lacks detail on format or precision, and does not mention the odd 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?

No guidance on when to use this tool versus alternatives. There is no mention of when it is appropriate or when not, and no comparison with sibling tools like timezone or calc-eval.

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 and parameter notes disclose that inputs are discarded and that no disk access occurs, which is useful given no annotations are provided. However, it does not mention error behavior, side effects, or rate limits, 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?

The description is extremely concise, with only two short sentences and no redundant wording. It is front-loaded with the primary purpose and avoids unnecessary elaboration.

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 does not state what the tool returns, such as a boolean, error message, or report. An agent cannot fully infer expected output or failure behavior from the provided information.

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 a description, so the baseline is met. The descriptions add meaning, but many parameters (url, city, feed, host, zone, query) seem unrelated to JSON validation and create confusion about the tool's actual input contract.

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: 'Check whether a body is valid JSON.' This distinguishes it from sibling check tools by resource type. However, 'body' is not explicitly linked to the 'json' parameter, leaving slight ambiguity.

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

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

The description gives no guidance on when to use this tool versus alternatives such as file-path-ok or browser-url-ok. It does not mention prerequisites, preferred input, or conditions that would make this tool the right choice.

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 burden. It does not disclose that the tool accepts many other parameter types, nor any side effects, return format, or error behavior. The narrow description is potentially misleading given the schema.

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

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

The description is a single concise sentence with no fluff, but it is under-specified. Conciseness itself is good, but it sacrifices necessary 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 9 parameters, no output schema, and no annotations, the description is grossly incomplete. It only addresses the city parameter and ignores the other eight, leaving agents unable to understand the full tool behavior.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The tool description adds no additional meaning beyond restating the city parameter's purpose, so 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 specific function (current temperature for a city via Open-Meteo), but the input schema reveals many unrelated parameters (ref, url, json, etc.), suggesting the tool's scope is broader than described. This creates ambiguity about the tool's full purpose, though the core weather function is 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?

No guidance on when to use this tool versus its siblings like geo-hint or iana-zones. The description does not mention any conditions or alternatives.

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

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

The description discloses a key behavioral trait: the body is discarded and only HTTP status and content type are returned. It also constrains the input to public URLs. With no annotations, however, it omits details such as HTTP method, redirect handling, timeout/error behavior, and the fact that most schema parameters appear to be unrelated to the stated URL fetch.

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 zero wasted words; the main purpose is front-loaded and the side effect (body discarded) is stated immediately after. This is an exemplary concise description.

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

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

The tool has nine optional parameters, no annotations, no output schema, and many closely related siblings, yet the description only addresses fetching a URL. It does not explain the role of the other parameters, how results are formatted, or when this tool is preferred over alternatives, leaving a substantial completeness gap.

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

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

Schema description coverage is 100%, so each parameter already has an explanation. The tool description adds no parameter-level meaning beyond implying the url parameter is central, and it leaves the relationship of the other eight optional parameters unexplained. Baseline 3 applies because the schema carries the documentation burden.

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 discards the body. This gives a specific resource and observable output. However, it does not differentiate it from overlapping siblings such as fetch-status 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?

No guidance is given on when to use web-fetch versus sibling tools like fetch-status, normalize-url, or browser-url-ok. There are no prerequisites, exclusions, or conditions that would help an agent choose 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?

No annotations exist, so the description carries the full burden. It only mentions 'Title discarded after the call,' but there is no title parameter in the schema, making this note irrelevant and potentially confusing. No side effects, permissions, rate limits, or response behavior are disclosed.

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

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

The description is a single sentence, which is concise in length, but it is severely under-specified. It does not explain the tool's behavior relative to its parameters, making it more of a placeholder than a helpful definition. The statement about discarding a title is not only irrelevant but also fails to earn 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?

With nine parameters, no output schema, and no annotations, the description is completely inadequate. It does not explain what the tool actually does with the parameters, what it returns, or when to use it. The agent cannot determine correct invocation from this definition alone.

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

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

Although schema description coverage is 100%, the parameter descriptions are generic (e.g., 'Git ref name', 'HTTPS URL') and do not connect to the stated purpose of checking a Wikipedia title. The tool description adds no meaning about how these parameters are used, and the mismatch between the description and schema leaves the agent without any semantic 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 specific purpose ('Check whether a Wikipedia title exists') that aligns with the tool name, but it directly contradicts the input schema, which lists nine generic parameters (ref, url, city, feed, etc.) unrelated to Wikipedia titles. This mismatch makes the purpose 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?

No guidance is provided on when to use this tool versus the many siblings (browser-url-ok, fetch-status, normalize-url, etc.). There are no conditions, exclusions, or alternative references, leaving the agent without any decision support.

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