Language qu

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

Since annotations are absent, the description carries the full burden of behavioral disclosure. It only states that 'Task text discarded' and that connection methods are returned, but does not disclose whether the tool has side effects, requires authentication, or how much of the input is truly processed. This is minimal for a tool that accepts 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 two short sentences with no filler. It front-loads the primary action and return type, and the discarding behavior is mentioned early. It is appropriately concise, though one might argue it omits needed details in favor of 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?

For a tool with 9 parameters and no output schema, the description is incomplete. It does not explain what 'connection methods' look like, how they are structured, or how to use them. It also fails to explain the role of the many discarded parameters (ref, json, path, zone, query) – whether they are used to route the task or are just noise. This leaves an agent uncertain about how to call the tool effectively.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description does not add meaning beyond the schema; it only mentions 'task text discarded' without connecting that to the specific parameters. A baseline of 3 is appropriate because the schema does the heavy lifting, but the description fails to add any contextual value about how parameters relate to the gateway discovery.

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-resource pair: 'find a public pay-per-call tool gateway' and mentions example task categories (weather, search, scrape, voice) plus the return type ('connection methods'). It distinguishes itself from sibling tools by focusing on gateway discovery rather than performing the task itself, though the phrase 'such as' leaves the scope slightly open.

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

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

No explicit guidance is given about when to use this tool versus alternatives. The description mentions task categories but does not name or exclude any sibling tools, nor does it clarify scenarios where this tool is more appropriate than directly invoking a weather-hint or web-fetch. The expected usage is only implied.

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

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

With no annotations, the description carries the burden in behavioral disclosure. It does add one useful fact: 'No browser is launched.' However, it fails to explain what 'can be opened' means (HTTP checkout, syntax-only check, etc.), what side effects or network requests occur, or what the output is. This is insufficient for a standalone tool with no annotation backup.

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 wording is tight and front-loaded: two short sentences with no filler. However, for a tool with nine optional parameters and no output schema, this brief treatment is under-specified rather than appropriately sized. It is concise but at the cost of essential detail.

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

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

The description is not enough to invoke the tool correctly. It ignores the existence of nine parameters, including apparently unrelated fields like city, json, ref, and zone. An agent is left unsure whether these are relevant or how they interact. With no output schema and no return format, the description leaves major context 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%, and each parameter already has a descriptive schema comment, so the baseline of 3 applies. The tool description adds no parameter-level semantics, but that is not critical where the schema is fully documented. It does not hurt or help.

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

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

The description states a specific verb and resource: 'Check whether a URL can be opened.' The 'No browser is launched' clause distinguishes it from siblings like playwright-url-ok that might invoke a browser. It does not name those siblings explicitly, but the core purpose is unambiguous.

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

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

There is no guidance on when to choose this tool over alternatives such as fetch-status, normalize-url, or playwright-url-ok. No when-to-use, when-not-to-use, or prerequisite conditions are given, leaving an agent without direction for tool selection.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions only that the expression is 'discarded', but it does not disclose any side effects, permissions, rate limits, or what happens to the parameters. Moreover, the description's claim of arithmetic evaluation is not supported by the schema, and there is no detail about the operation's effects. This is grossly 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 extremely short, but this is under-specification, not effective conciseness. It front-loads a false purpose and provides no actionable information. A one-sentence description that fails to address the tool's actual nature is not concise; it is incomplete.

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 must compensate but does not. It provides no explanation of the tool's actual functionality, how parameters are used, what is returned, or any dependencies. This is completely inadequate for an agent to correctly invoke the tool.

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

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

While the input schema provides descriptions for each parameter (100% coverage), the tool description adds no meaning beyond that. The baseline is 3, but the description actually misleads by suggesting an arithmetic operation, while the parameters are clearly about URL, file, and text checks. The description does not explain how any parameter relates to the claimed arithmetic evaluation, so it actively undermines parameter understanding.

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

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

The description claims to 'Evaluate a+b style arithmetic', which is a clear verb and resource, but it completely fails to align with the input schema, which contains 9 unrelated parameters like git refs, URLs, cities, and JSON. This mismatch makes the purpose vague and misleading; an agent cannot reliably infer what this tool actually does with the given parameters. It also does nothing to distinguish itself from the many sibling tools that perform validation or checking tasks.

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 whatsoever on when to use this tool versus its siblings. It does not state any context, prerequisites, or exclusions. The description is a single sentence with no indication of appropriate use cases, making it entirely unhelpful for selection.

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

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

With no annotations, the description must carry the full burden. It discloses one behavior ('Page content is not stored'), which is useful, but it fails to explain the purpose or effect of the other eight parameters (city, feed, json, path, zone, etc.) that appear in the schema. The description only addresses the 'url' parameter, leaving the agent unsure whether these other parameters are ignored, rejected, or trigger different behaviors. This is a significant transparency gap.

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

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

The description is two short sentences with no filler. The core purpose is front-loaded, and the behavioral note follows immediately. Every word earns its place, achieving maximum clarity with minimal text.

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

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

Given the tool has 9 optional parameters and no output schema, the description is far from complete. It explains only the URL behavior and return of three fields, but does not clarify what happens with the other parameters, how the tool handles invalid inputs, or what the exact output format is (beyond listing three properties). An agent cannot correctly call this tool without additional knowledge, especially since the schema hints at a multi-purpose behavior not reflected in the description.

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

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

Since schema description coverage is 100%, the baseline is 3. The description adds no additional meaning beyond the schema; it does not elaborate on the url parameter's format or explain the relationship of the other parameters. The agent receives no extra semantic guidance from the description, so the score stays at the baseline.

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

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

The description states a clear verb and resource: 'Return host, scheme, and HTTP status for a URL.' It also adds a distinguishing constraint ('Page content is not stored') that separates it from content-fetching tools like web-fetch. The specificity makes the tool's purpose obvious and distinct from siblings.

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

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

The description clearly implies when to use the tool (when needing host, scheme, and HTTP status without storing content), but it does not explicitly state when NOT to use it or mention alternative tools among the many siblings (e.g., fetch-status, normalize-url). No exclusions or comparisons are provided, leaving selection to inference.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The phrase 'No identifiers are retained' hints at a non-retention guarantee, but it does not clarify side effects, read-only status, or what happens to the input beyond discarding identifiers. It also does not explain what 'classified' means operationally. This is minimal context, not adequate transparency 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 extremely short with two sentences, but brevity is not the same as conciseness. The first sentence is vague and does not earn its place as a useful purpose statement. The second sentence (privacy) is the only concrete detail. It is front-loaded, but the content is insufficient for the tool's complexity. A 3 reflects that it is not bloated but also not effective.

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

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

Given 9 optional parameters, no output schema, and no annotations, the description is far from complete. It does not state what the return value looks like, what classification options exist, how the parameters relate, or any usage caveats. The privacy note is a small fragment, but overall the description leaves agents with insufficient information to call the tool correctly or interpret 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 description coverage is 100%; all nine parameters have descriptions in the schema. The tool description itself adds no parameter-level meaning beyond what the schema provides. It does not explain how these disparate inputs (ref, url, city, feed, etc.) feed into the classification. The baseline of 3 is appropriate since the schema documents each parameter individually, but the description fails to tie them to 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 states a verb and object ('Show how this request is classified'), but 'this request' and 'classified' are vague. It does not specify what kind of classification (e.g., compatibility with what?) or how it relates to the tool name. There is no distinction from sibling tools like domain-shape or fetch-status. It is a vague purpose, not a tautology, but far from a specific resource and action.

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. It does not mention scenarios, prerequisites, or exclusions. The only added context is a privacy statement ('No identifiers are retained'), which does not help with selection. Agents have no basis to prefer this over siblings.

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

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

With no annotations provided, the description must carry the full behavioral burden. It only says 'without WHOIS or ownership data', which hints at one constraint, but fails to disclose the 'shape check' behavior hinted by the parameter descriptions ('discarded after the shape check'). The inconsistency between 'split' and 'shape check' leaves behavior opaque.

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

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

The description is a single, front-loaded sentence with no fluff, but it is so terse that it omits essential information. Conciseness is achieved at the expense of clarity, which is a trade-off that warrants a mid-range score.

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

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

With 9 optional parameters, no required fields, no output schema, and no annotations, the description is severely incomplete. It fails to explain what the tool returns, how the parameters are used, or how the 'shape check' works. An agent cannot confidently call this tool based on 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%, so each parameter has a description, but the tool description does not explain how any of these parameters relate to splitting a hostname. The mention of 'discarded after the shape check' in the schema is the only hint, yet the tool description never ties the parameters to its stated purpose, adding no semantic value beyond the schema.

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

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

The description states a specific verb and resource ('split a hostname into labels'), but it contradicts the breadth of the input schema, which accepts city, feed, json, path, zone, query, and more. The stated purpose does not match the tool's actual parameter surface, making it confusing for an agent to discern what the tool actually does.

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

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

No mention of when to use this tool versus siblings like 'url-ok', 'geo-hint', or 'validate-json'. There is no guidance on prerequisites, exclusions, or alternative selection, leaving the agent to guess which tool fits a given task.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only mentions a HEAD request and status-only return, but does not explain how the other parameters are used, whether they trigger distinct operations, or any side effects. The schema's 'discarded' notes are not mentioned in the description, so an agent cannot infer the behavior for non-URL inputs.

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

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

The description is one sentence and front-loaded, which is concise, but it is under-specified for a tool with 9 parameters. It is not harmful, but it omits crucial details, making it inadequately concise rather than efficiently informative.

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, this description is grossly inadequate. It does not explain the tool's multi-purpose nature, what happens for non-URL inputs, or what the return format is. Agents would be unable to call it correctly for most parameters.

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

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

Schema description coverage is 100%, so every parameter already has a textual explanation. The tool description adds no parameter-specific information, relying entirely on the schema. Baseline 3 is appropriate given the 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 states a specific action ('HEAD a public URL and return status only'), but the schema lists 9 unrelated parameters (timezone, JSON, city, etc.), suggesting a much broader purpose. This narrow focus does not capture the tool's actual scope and may mislead an agent into thinking it only handles 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?

No guidance is given on when to use this tool versus siblings like web-fetch, browser-url-ok, or validate-json. The description provides no conditions, alternatives, or exclusions, leaving selection to chance.

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

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

There are no annotations, so the description must carry behavioral disclosure, but it only says 'Path discarded.' It does not say what the tool returns, what counts as a valid or invalid Figma URL shape, whether a network access is made, or what errors might occur.

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

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

The description is short and front-loaded, which is structurally fine, but it is so under-specific that it provides almost no useful information in its two sentences. 'Path discarded' is vague enough to be of limited value.

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

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

Given the tool has nine parameters, no output schema, and no annotations, the description is far from complete. It leaves the input selection, return format, validation behavior, and error handling entirely unclear.

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

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

The input schema already describes all nine parameters, all with text in the schema (100% coverage). The top-level description adds very little parameter-level meaning and does not clarify which of the nine parameters are relevant for a Figma URL parse.

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

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

The phrase 'Parse a Figma file URL' names a specific resource, but 'Path discarded' is ambiguous and the tool name suggests shape checking that the description never explains. It does not distinguish this from sibling shape tools like normalize-url or github-repo-shape beyond the resource name.

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

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

No guidance is given for when to prefer this tool over the many sibling URL/shape/checked tools. There are no exclusions, prerequisites, or fallback directions, so an agent cannot make a selection from the description alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does state 'No disk access,' which is a useful safety note, but it does not explain how 'looks safe' is determined, how the other 8 parameters are handled, or what the return value looks like. This is minimal transparency for a tool with such a broad parameter set.

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 front-loads the primary action and constraint. It is efficient with no wasted words. The under-specification is a completeness issue, not a conciseness issue, so it earns a high mark for structure.

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

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

The tool has 9 optional parameters, no output schema, and no annotations. The description only covers the path parameter and says nothing about the other parameters, which appear to be core to the tool's actual function. An agent cannot determine how to use the tool for non-path inputs or what result to expect. This is a significant 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?

The schema provides descriptions for all 9 parameters (100% coverage), so the tool description adds no additional parameter-specific meaning. It only mentions 'path' and repeats the 'no disk access' note already present in the schema's path parameter. Since schema coverage is high, the baseline score of 3 is appropriate; the description does not enhance or clarify parameter semantics.

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

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

The description states a specific action ('Check whether a path looks safe') and a key constraint ('No disk access'). However, the input schema defines 8 additional parameters (ref, url, city, feed, host, json, zone, query) beyond 'path', indicating the tool actually validates many kinds of inputs. The description only addresses path, making the tool's full purpose ambiguous and failing to differentiate it from siblings like validate-json 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 provided on when to use this tool instead of alternatives. The description only mentions path safety and does not reference the sibling tools that handle URLs, JSON, geolocation, etc. An agent would not know whether to call this tool for validating a URL or JSON, or to call a specialized sibling.

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 given, so the description carries the full behavioral burden. It mentions the external provider 'Open-Meteo', but it does not disclose network-side effects, read-only behavior, error cases, or which input drives the lookup.

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

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

The description is compact and front-loads the essential function in one sentence. It is not verbose, though the brevity comes at the cost of missing operational detail.

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

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

For a tool with 9 optional parameters, no required parameters, no output schema, and no annotations, this one-sentence description is insufficient. An agent cannot determine which parameter to provide, what the resolved coordinates look like, or what Open-Meteo invocation will happen.

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

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

Schema description coverage is 100%, so the baseline is 3 even without parameter details in the tool description. However, the description adds no mapping from 'place' to any specific parameter such as city, and the city schema description is framed as a weather hint rather than a geocoding 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 core capability: returning latitude and longitude for a place via Open-Meteo. It is a specific and recognizable task, though it does not differentiate this tool from sibling helpers or identify which schema parameter supplies the 'place'.

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 like weather-hint or normalize-url, and no conditions or exclusions. The phrase 'for a place' only weakly implies the query scenario but is too vague to support tool selection.

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 says 'Parse owner and repo from a GitHub URL' but the input schema includes 9 parameters, most of which (city, feed, host, json, path, zone, query) are completely unrelated to the stated purpose. This creates confusion about what the tool actually does with those inputs and whether it is a generic shape validator. The description does not disclose that it may handle other input types, nor does it explain the discarded parameters mentioned in the schema. This is a serious transparency gap that could mislead an agent.

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

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

The description is extremely concise (one phrase) and front-loaded with the core action. However, it lacks structure and explanatory detail, failing to mention the presence of unrelated parameters or the tool's broader behavior. While brevity is a virtue, it is under-specified for a tool with 9 parameters and no output schema, so it earns a mid-range score.

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

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

For a tool with 9 parameters, no annotations, and no output schema, the description is far from complete. It does not explain return values, error behavior, or the purpose of the many unrelated parameters. The description is insufficient to guide an agent on how to call the tool correctly, especially since it appears to be part of a family of similar 'shape' tools but is not distinguished adequately.

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 documented in the schema. The tool description adds no additional meaning about parameters, but the baseline of 3 applies because the schema already provides adequate descriptions. The description's silence on parameters does not reduce clarity, but it also does not enhance it beyond what the schema offers.

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 ('Parse') and a clear resource ('owner and repo from a GitHub URL'). It is unambiguous about the core function. However, it does not explicitly differentiate from sibling shape tools like domain-shape or figma-url-shape, relying on the GitHub-specific resource to make the distinction implicit.

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 its siblings. There is no mention of alternatives, conditions, or exclusions. An agent would have to infer from the name and the phrase 'GitHub URL' that this is the tool for GitHub repo extraction, but no explicit routing is given, especially given the large number of sibling shape tools.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only mentions that titles are discarded, but it does not disclose what the tool returns, any network effects, or the purpose of the many unrelated parameters. Significant ambiguity remains about how the tool behaves.

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 concise sentences with no filler. The core action is front-loaded, and the supplemental detail about titles is brief yet useful.

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 far too minimal. It does not explain how the parameters are used, what the return value looks like, or why so many fields are accepted. A more complete and contextual description is necessary 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?

The schema already describes all 9 parameters (100% coverage), so the baseline is 3. The tool description adds no parameter-specific information, and the schema's parameter descriptions are unrelated to the stated function, but the description itself does not contribute negatively.

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 verb 'Count' and the resource 'current Hacker News front-page stories,' with an explicit qualifier that titles are discarded. This makes the tool's purpose unambiguous and distinct from other counting tools in the sibling list.

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 description gives no context about suited use cases, prerequisites, or when another tool might be preferable. A clear 'when to use' is missing.

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 available, the description must disclose behavior, but it offers none. There is no mention of side effects, return format, rate limits, or what happens with the input parameters (which are described as 'discarded' in the schema but not in the tool description).

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

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

The description is extremely short (one sentence) but this is not concise clarity; it is cryptic under-specification. Key information is missing, and the single sentence does not front-load a clear purpose or any operational detail.

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

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

Given the tool has 9 parameters, no output schema, and no annotations, the description is wholly inadequate for an agent to understand what to provide or what to expect. The absence of any behavioral or operational detail leaves the tool effectively unusable without guessing.

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 covers all parameters with descriptions, the tool description adds no meaning beyond that. The parameters (ref, url, city, feed, host, json, path, query) appear unrelated to 'IANA timezone names', and the 'zone' parameter is only listed as 'IANA timezone name' without explaining its role relative to 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' hints at a resource or reference list but lacks a clear verb or action. It doesn't specify whether the tool returns, validates, or filters timezone names, and provides no differentiation from siblings like 'timezone' or 'utc-time'.

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

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

No guidance is provided on when to use this tool versus alternatives. The description only mentions 'clock calls' without explaining the context or exclusions, and it never references sibling tools.

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

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

With no annotations, the description must carry behavioral disclosure. It states the core action and outcome but omits network implications, parameter dependencies, error behavior, or that it discards other parameters. The schema hints at discarded parameters, but the description itself does not reveal these traits.

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 direct sentence with no filler. The action is front-loaded and the sentence is appropriately sized for the tool's narrow focus.

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 incomplete for a tool with 9 optional parameters. It does not explain how to specify the target URL, what 'group counts' means, whether the tool actually makes a network request, or what happens with other parameters. Without an output schema or more context, an agent cannot reliably 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?

Schema coverage is 100%, so the baseline is 3, but the parameter descriptions are generic and unrelated to robots.txt (e.g., 'City name for a public weather hint'). The tool description does not clarify which parameter actually targets the robots.txt URL, leaving the mapping ambiguous. It fails to add 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 action ('Fetch a public robots.txt') and a distinct result ('return group counts only'). This is clear and distinguishes it from sibling web tools like web-fetch or fetch-status, which do not mention robots.txt parsing or group counts.

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 context on when to use this tool versus alternatives, no exclusions, and does not mention any conditions for use. An agent has no guidance on whether to pick this over web-fetch or other URL tools.

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

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

The only behavioral disclosure is 'Key discarded', which informs that the input value is not kept. There are no annotations to provide safety or side-effect details, and the description does not state whether the tool is read-only, whether it performs network access, or what happens when a key does not match. Because the description carries the full burden without annotation support, this is a sparse transparency profile.

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

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

The description is two short sentences, front-loading the core operation in sentence one and adding a behavioral note in sentence two. There is no redundant filler, and the most important context appears first. The concise structure is a positive point, though the brevity also contributes to the lack of completeness.

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 whose purpose is checking a Jira key shape, an agent needs to know which argument holds the key, what the return value means, and whether the check has side effects. The description provides none of these, and the input schema is generic and not tied to the purpose. Without an output schema or a clear parameter engagement, the tool is effectively unusable from this definition.

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

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

The input schema exposes nine parameters with generic descriptions (URL, ref, city, feed, host, json, path, zone, query), none of which is named 'key' or labeled as the identifier for the Jira key shape check. The description adds no mapping or clarification on which parameter should be passed, making it impossible for an agent to invoke the tool correctly. This is a critical semantic gap that the description does not compensate for despite the 100% schema description 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 explicitly says 'Check a Jira issue key shape', which is a specific verb ('check') plus a resource ('Jira issue key'). This differentiates it from the many sibling shape validators because it targets Jira keys. However, it does not spell out what a Jira key shape looks like (e.g., PROJECT-123), and the input schema lacks a 'key' field, so the object of the check is not tied to a concrete parameter.

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

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

The description gives no guidance about when to use this tool instead of the many shape-checking siblings (domain-shape, figma-url-shape, github-repo-shape, etc.). It does not mention criteria, alternatives, or any scenario in which this is the appropriate call. An agent is left unsupervised on which tool to pick for a Jira key check.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It discloses nothing about side effects, output, validation behavior, errors, or discarded inputs. This is a severe 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 short, but this is under-specification rather than useful conciseness. There is no structured information or front-loaded operative detail to help an agent.

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

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

With 9 optional parameters, no output schema, no annotations, and a one-phrase description, the definition is far from complete. An agent cannot infer what valid invocations are, what the tool returns, or how the parameters relate to the stated language tag.

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

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

All 9 parameters already have descriptions in the input schema, so schema coverage is 100% and the baseline is 3. The tool description itself adds no parameter meaning, but the schema does the heavy lifting; the description does not compensate for the wider mismatch between its stated language-tag purpose and these heterogeneous parameters.

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

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

The description is just "ISO 639 language tag qu." It restates the tool name without a verb or stated operation: the agent cannot tell whether the tool validates, returns, normalizes, or checks a language tag. It provides no differentiation from siblings like jira-key-shape or normalize-url.

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

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

There is no guidance about when to invoke this tool, what problem it solves, or when a sibling tool would be preferable. The static phrase gives no contextual basis for usage decisions.

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

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

With no annotations, the description carries the behavioral burden. It does reveal that the body is discarded and the word 'public' implies no authentication requirement, but it does not explain redirects, failure outcomes, or how the unrelated optional parameters (city, json, zone, query, etc.) are treated.

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

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

Two short sentences with zero filler; the core act is front-loaded and the body-discard caveat is placed second. Everything present earns its place.

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

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

For a tool with 9 optional parameters, no output schema, and no annotations, the description is far too thin. It does not say which parameter carries the target URL, what happens when multiple parameters are supplied, what the status response looks like, or how to choose this over sibling checkers.

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

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

Schema coverage is 100%, so each parameter is already documented individually, setting the baseline at 3. The description adds no parameter-specific meaning and does not state which parameter should receive the 'public library docs URL', so it provides no added value beyond the schema here.

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

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

The description clearly states the operation: obtain HTTP status for a public library docs URL, and explicitly notes the body is discarded. It is not a tautology and identifies a concrete resource, but it does not distinguish this from sibling URL/status tools and leaves the 9-parameter schema unaddressed.

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 lib-docs-hint versus siblings such as fetch-status, browser-failure-ok, normalize-url, or web-fetch. The 'body discarded' caveat vaguely hints at status-only use, but no explicit when/when-not criteria are present.

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

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

With no annotations provided, the description carries the full burden of disclosure. It reveals that values are discarded and that the tool counts keys, but it remains silent on failure modes (e.g., invalid JSON, non-object input), output format (does it return just a number?), and any side effects. This is only minimal transparency; an agent cannot fully anticipate the tool's behavior based on this description alone.

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 that gets to the point quickly. However, it lacks structure that connects to the parameter list—there is no mention of how the parameters map to the action, and the return value is not hinted at. It is concise but not well-packaged for an agent to grasp the full interface, especially given the array of parameters.

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, no output schema, and a description that addresses only the generic notion of counting keys, this definition is severely incomplete. It provides no explanation of how agents should supply the JSON object (via 'json' parameter? or other parameters that encode a reference?), what the output format is, or how the tool handles edge cases. An agent cannot reliably invoke this tool correctly with the given 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 description coverage is 100%, so each parameter already has a textual definition. The description 'Count keys in a JSON object' adds the specific action (counting) beyond the schema's generic 'validate' wording for the 'json' parameter, giving agents a more precise expectation. However, the description does not reconcile the other 8 parameters (e.g., 'city', 'query') which are described as being discarded after checks, leaving ambiguity about how they relate to counting. The baseline of 3 is appropriate since the schema handles most 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?

States a clear verb ('Count') and specific resource ('keys in a JSON object'), and further clarifies that values are discarded, which distinguishes it from validation tools. However, it does not explicitly differentiate from sibling tools like 'validate-json' or 'domain-shape', and the presence of 9 unrelated-looking parameters (city, query, path, etc.) that the description never addresses muddies the intended scope.

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, when not to use it, or what alternatives exist. The description is a bare functional statement with no conditions or exclusions, leaving the agent to infer applicability from context 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 disclosure burden. It does transparently state that query and fragment are dropped, but it does not disclose that the rest of the 8 schema parameters are effectively ignored, nor does it clarify what happens with invalid URLs or whether the 'normalize or cite' behavior in the `url` parameter description applies.

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

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

Two short, front-loaded sentences make this very concise. The key value proposition and core transformations are present without fluff.

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

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

Despite the clear core purpose, the tool is not contextually complete for the given input schema. The description does not explain that only `url` matters, does not reconcile the 'normalize or cite' hint in the `url` schema, and provides no output format or error behavior, making it risky for an agent to call correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds semantics for the `url` parameter by explaining normalization drops query/fragment, but it does nothing for the other 8 parameters, leaving potential confusion about which to use.

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

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

The description clearly states the tool's main action: return origin, host, and path for a URL, and explicitly defines what is dropped (query and fragment). This is a specific verb and resource that distinguishes it from sibling shape/check tools like browser-url-ok or web-fetch.

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

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

The description provides no guidance on when to use this tool versus alternatives such as extract-domain-url, fetch-status, or domain-shape. It doesn't state any exclusions or mention that the only meaningful parameter is `url`, given the schema contains many unrelated fields.

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 usefully declares that no browser is launched, which is a meaningful side-effect statement. However, it fails to disclose whether a network request is made, what the return value means, or how the check behaves when a URL is unreachable.

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

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

The description is two short sentences with no filler, front-loading the core action first. 'Check whether a URL can be opened. No browser is launched.' is efficiently packaged and 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 optional parameters, no output schema, and no annotations, this minimal description leaves critical gaps. The agent does not know what the tool returns, what the unrelated optional parameters do, or what prerequisites exist (e.g., URL format, network access). Such a sparse definition is not enough 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?

The input schema has 100% description coverage for all 9 parameters, so the baseline is 3. The tool description does not add any additional meaning beyond naming the URL check itself; it does not clarify the role of the other eight parameters or any constraints on the URL value. Therefore, it neither harms nor greatly enriches the schema descriptions.

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

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

The description states a specific action ('Check whether a URL can be opened') and resource (a URL), which is clear and distinct from a mere tautology. However, it does not differentiate from sibling tools like 'browser-url-ok' or 'web-fetch', so an agent cannot infer which sibling to choose without further 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 given about when to use this tool versus alternatives. The phrase 'No browser is launched' hints at a selection criterion but does not name sibling tools or provide explicit conditions. An agent is left to infer the appropriate 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 available, the description carries the transparency burden. It adds one genuine behavioral detail—'Query discarded'—which indicates the operation has no lasting side effect on the input. It does not fully describe side effects for the other parameters or what the actual return value shape is, so it is not very complete but does provide useful evidence.

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

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

The description is only two short sentences and avoids all fluff. It fronts the main purpose and then adds a valuable behavioral note. There is no redundant or filler content, making it highly efficient.

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

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

The tool is simple and the description captures its core behavior, but with 9 params and no required fields, the description does not explicitly point the agent to which parameter to populate. It also omits the return value format, and the many distractor params in schema could confuse a caller without a clear 'use the query parameter only' message. Still, schema descriptions fill some of these gaps, so it is minimally complete.

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 this is the baseline for a description that adds nothing extra. The description references 'search query' but does not explicitly map that to the `query` parameter, nor does it clarify that the other eight params are ignored. The schema itself covers param details, so the description adds limited new semantic value.

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

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

The description clearly states the tool's function with a specific verb and resource: 'Count characters in a search query.' It is unambiguous and distinguishes this from sibling length/count tools by its focus on a search query. The second sentence adds a clean behavioral note without muddying 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, such as when a search-query length is needed or when no counting should be done. It does not mention any alternate tools or exclusion criteria. The instruction is fully absent beyond the purpose itself.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'catalog' without explaining what side effects or checks occur. For example, it does not state whether inputs are validated, normalized, or merely cited. The description does not disclose any behavior beyond a vague reference to status codes.

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, almost minimalist, but this does not qualify as effective conciseness because it omits crucial information. There is no structure, no front-loading of the operation, and every sentence (the single phrase) fails to earn its place by adding meaningful 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 nine parameters, no output schema, and no annotations, the description is severely incomplete. An agent cannot determine how to invoke it correctly or what result to expect. The description does not address any of the parameters or explain the tool's relationship to HTTP status codes, making it impossible to use safely.

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

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

The input schema has 100% description coverage, and each parameter includes a short note (e.g., 'Git ref name; discarded after the shape check'). However, the description adds no meaning that connects these parameters to the tool's purpose. It is unclear why a catalog of HTTP status codes needs city names, timezones, or file paths. The schema descriptions are individually useful but collectively they do not explain how the tool uses them.

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

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

The description states it is a 'Short catalog of common HTTP status codes', which identifies a resource but not the operation performed. It is unclear whether the tool returns a status code, validates one, or provides a reference. The nine input parameters (ref, url, city, feed, host, json, path, zone, query) bear no obvious relation to HTTP status codes, leaving the tool's actual behavior ambiguous. It also does not differentiate from sibling tools like 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?

There is no guidance on when to use this tool versus any sibling. It does not mention any conditions, prerequisites, or alternatives. An agent would have no idea how to decide that status-catalog is 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 the burden of behavioral disclosure. 'Prompt discarded' is a genuinely useful transparency signal — it tells the agent all 9 parameters are throwaway. However, it stops there: no effect, no side-effect statement, no return-format caveat. A 3 credits the one meaningful disclosure it does make.

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 that put the purpose first and the discard caveat second. Zero wasted words, and the key behavioral fact (input ignored) is front-loaded. This is exemplary 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?

Despite having 9 parameters and no output schema or annotations, the description explains nothing about what the returned template contains, how to interpret it, or whether it's safe/repeatable. For an agent the result is essentially opaque — it can call the tool but cannot reason about the outcome. Two sentences are not enough for a tool this bare.

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

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

Schema coverage is 100%, so the baseline is 3. Each parameter's schema description already explains that its value is 'discarded after the check.' The tool-level 'Prompt discarded' sentence reinforces this but adds no meaning beyond what the structured schema conveys, so it stays at the baseline.

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

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

The description says it returns a 'three-step thinking template' but never defines what that template is or what it's for. 'Think-steps' and 'three-step thinking template' are near-tautologies, and nothing distinguishes this from the 27 sibling utility tools that also probe inputs (search-query-len, validate-json, domain-shape).

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

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

The only contextual hint is 'Prompt discarded,' which says the input is ignored but gives no guidance on when to call this versus any sibling. There is no when-to-use, when-not-to-use, or alternative routing. An agent has no way to know this is a debugging probe rather than a substantive 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?

Without any annotations, the description must carry the behavioral disclosure. It states only that the tool returns current time in a named timezone but says nothing about invalid zone handling, return format, timezone edge cases (DST), or the meaning of the other eight schema parameters. The presence of many unrelated parameters without explanation leaves ambiguous 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?

A seven-word sentence states the core function with zero redundancy. The opening words 'Current time' instantly convey the result, and the rest specifies the scope. This is an appropriately sized description for a simple read-only tool.

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

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

The tool is simple but the schema contains nine parameters, and the description does not clearly indicate that 'zone' is the only relevant parameter. There is no output schema, but the description's 'Current time' partially conveys the return. It lacks completeness by not clarifying the role of the other params or return format, but it is adequate for a minimal 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 baseline is 3 even though the description adds no parameter-level detail. The schema already documents 'zone' as an IANA timezone name and marks the other parameters as discarded; the description provides no extra guidance on which parameter to supply or how the others interact with the tool.

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

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

Description names a concrete verb and resource ('Current time in a named IANA timezone') and distinguishes the tool from siblings such as utc-time (UTC only) and iana-zones (zone list). The single-sentence statement fully conveys the tool's purpose.

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

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

No guidance on when to choose this over alternatives like utc-time or iana-zones, nor any mention of restrictions or preferred contexts. The description implies use for a specific timezone but does not explain boundary cases or alternative tools.

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

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

No annotations are provided, so the description must carry full behavioral disclosure. The description only states 'Current UTC timestamp.' It does not disclose that all input parameters are optional and effectively ignored (as indicated by their 'discarded' notes in the schema). This omission could mislead an agent into thinking parameters affect the output. The tool's behavior is not transparent regarding the parameter irrelevance, and there is no mention of side effects or safety.

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, compact sentence with no filler. It front-loads the essential information. However, given the complex schema, a slightly longer description explaining that parameters are ignored would be justified. Still, for what it says, it is concise and well-structured. The brevity doesn't detract beyond the missing context.

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

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

The tool has 9 parameters, all optional, and no output schema. The description does not explain the role of these parameters, nor does it clarify that they have no effect on the returned timestamp. An agent might attempt to populate parameters based on their names, leading to unnecessary calls. The description is incomplete for a tool with such a misleading parameter list. It should explicitly state that parameters are ignored or used only for validation checks with no impact on the output.

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%: each of the 9 parameters has a description. The descriptions clarify that most parameters are 'discarded' after checks, so they carry some semantic weight. However, the tool description itself adds no value beyond the schema. It doesn't summarize that parameters are irrelevant to the timestamp output, and it doesn't clarify why they exist. The schema does the work, and the description adds nothing, so the baseline 3 applies.

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

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

The description states a specific verb and resource: 'Current UTC timestamp.' It clearly identifies the tool's output. However, it doesn't distinguish from sibling tools like 'timezone' or 'iana-zones', which could also deal with time and timezones. The name itself clarifies UTC, but the description could mention when to use this vs. the timezone tool. Still, the core purpose is unambiguous and specific.

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

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

No guidance is provided on when to use this tool versus alternatives like 'timezone' or 'iana-zones'. The description is purely factual and doesn't mention exclusions, preconditions, or typical use cases. An agent gets no help deciding between this and related tools.

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

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

No annotations are present, so the description carries the full disclosure burden. It adds one behavioral note—'The body is discarded'—but this repeats the json property description and does not mention the return value, error behavior, or whether the other parameters are ignored or processed.

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?

With two short sentences, the description is front-loaded and contains no wasted words. It is sparse, but it is not the place where the tool's information is missing.

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

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

A nine-parameter tool with no annotations and no output schema needs more than a two-sentence description. The description does not state which parameter is 'the body,' what the validation returns, or why unrelated parameters like city and zone are part of the schema.

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

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

Schema coverage is 100%, and the schema already describes all nine parameters individually. The description loosely maps 'body' to the json parameter but provides no additional meaning for the remaining eight optional parameters, which a caller might expect to be relevant.

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

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

The description says it 'checks whether a body is valid JSON,' which is a specific verb (check) on a specific resource (JSON body) and is distinct from the other shape/check siblings like browser-url-ok or wiki-title-ok. The term 'body' is slightly ambiguous—it could mean the json parameter or some other request body—so it stops short of a perfect 5.

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

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

There is no guidance about when to use validate-json instead of alternatives and no exclusions or sibling references. The schema exposes nine parameters (e.g., url, city, zone, query) but the description does not explain whether any of these are relevant to the validation operation or when only the json parameter should be supplied.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the purpose without mentioning read-only nature, rate limits, failure modes, or how extraneous parameters are handled. The schema description of discarded parameters hints at behavior, but the tool description itself gives none.

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 purpose. However, it lacks any structured breakdown of the nine parameters, making it concise yet not optimally informative.

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 severely incomplete. It does not indicate which parameter is required, what the response format is, or how the tool behaves when irrelevant parameters are supplied, making correct invocation ambiguous.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds no extra parameter meaning; it only implicitly references 'city'. The schema descriptions themselves are terse and some (e.g., ref, query) seem unrelated to weather, but the description does not clarify their role.

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 (get current temperature) and resource (for a city) via Open-Meteo. It is specific about the primary purpose and distinguishes it from other hint tools, though it does not explicitly name alternatives.

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 siblings like geo-hint or lib-docs-hint. It does not mention scenarios, prerequisites, or exclusions, leaving 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 must carry the full burden of behavioral disclosure. It only mentions that the body is discarded, but says nothing about what happens to the other 8 parameters (e.g., ref, city, feed), whether network requests are made for each, or whether it performs format validation instead of live fetching. The description gives no insight into side effects, error behavior, or rate limits, and may actually mislead about the tool's full capabilities.

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 could be concise if it were complete, but it is under-specified given the tool's complexity. It withholds information about the other parameters and their behaviors, so it prioritizes brevity over utility. A more structured description that maps parameters to their intended checks would be more helpful.

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, this description is far too incomplete. It only addresses the URL case and gives no hints about return values, error handling, or how non-URL parameters are processed. Agents cannot confidently call this tool with anything other than a URL without risking unexpected 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%, and each parameter is already documented with its purpose (e.g., 'Git ref name; discarded after the shape check'). The description adds no extra meaning beyond what the schema provides. Since the schema does a good job of explaining parameters, a baseline of 3 is appropriate even though the description does not aggregate or contextualize them.

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

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

The description clearly states it returns HTTP status and content type for a public URL and discards the body. However, it does not explain the tool's broader purpose as a multi-parameter checker, nor does it distinguish itself from similar siblings like 'fetch-status' or 'normalize-url'. The verb+resource is specific but the scope is ambiguous given the 9-parameter schema.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that other tools like 'fetch-status' or 'validate-json' might be more appropriate for specific inputs, nor does it state any prerequisites or exclusions. Agents have no way to decide between this and 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?

The only behavioral note is that a title is discarded after the call, but the input schema exposes no `title` property. With no annotations provided, this minimal statement does not adequately disclose behavior such as return values, network effects, 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 short and front-loaded, but it is underspecified for a tool with nine optional parameters and no output schema. The second sentence is a behavioral note about a nonexistent title parameter, so not every sentence clearly 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 nine optional params, no required params, no annotations, and no output schema, the description is operationally incomplete. An agent cannot tell which parameter supplies the title, what the tool returns, or how to interpret success or failure.

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

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

Although all nine schema parameters have descriptions, the tool description does not connect any of them to the stated purpose of checking a Wikipedia title. The mention of 'title' refers to a concept absent from the schema, so the description adds confusion rather than meaningful parameter semantics.

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

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

The description clearly states the action and resource: checking whether a Wikipedia title exists. It is distinct from sibling check tools like browser-url-ok or file-path-ok, but the clarity is undercut because no `title` parameter exists in the input schema.

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

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

There is no guidance about when to use this tool over alternatives, what inputs are relevant, or what conditions should trigger its use. Given the large set of sibling check/shape tools, the routing context is missing.

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