Language zu

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

There are no annotations, so the description carries the full behavioral burden. It discloses only that task text is discarded and that connection methods are returned. It does not mention side effects, network calls, authentication needs, cost/billing implications, or the fact that all parameter values are also discarded; the schema descriptions carry most of that disclosure externally.

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

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

The description is concise at three sentences with the purpose front-loaded in the first sentence. The final sentence 'Task text discarded' is brief but slightly confusing since no 'task text' parameter exists; otherwise every line earns its place and there is no padding.

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

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

This tool has 9 optional parameters, no output schema, and a meta-indexing role, but the description does not explain how the parameters map to the named tasks, how the returned 'connection methods' are structured, or what the agent should do with them. An agent would be unsure which parameter to supply for a given task and what format to expect back.

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

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

Schema coverage is 100% and each of the 9 parameters already has a meaning-rich description in the input schema, so the baseline is 3. The tool description itself adds no parameter semantics beyond the task examples, and it does not explicitly map task categories (weather/search/scrape/voice) to parameters (city/query/url), which would have been valuable.

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

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

The description states a specific action (find) and resource (a public pay-per-call tool gateway) with concrete task examples (weather, search, scrape, voice), which clearly distinguishes it from the sibling 'hint' and 'shape' tools. It falls short of a 5 because 'connection methods' is somewhat vague and the final sentence '(Task text discarded)' does not map cleanly to any named schema property.

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 a light 'when to use' signal through task-type examples, but it never tells the agent when to choose this index instead of a direct sibling like weather-hint, web-fetch, or scrape-related tools. There are no exclusions, prerequisites, or explicit 'when not to use' guidance, so the agent must infer routing from the schema.

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

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

With no annotations provided, the description must carry the full behavioral burden. It does disclose one meaningful behavior—no browser is launched—but it does not say whether a network request is made, whether the check is purely syntactic, whether the tool is side-effect free, or what happens if the URL is invalid. This is too thin for a tool without annotation support.

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

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

The description is very concise: two short sentences with no filler, wasted words, or repetition. The core operation is stated first, and the important caveat about not launching a browser follows immediately, which is good front-loading for a definition this simple.

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 concise overall format, this tool has 9 optional parameters, no output schema, and no annotations, so contextually the description is insufficient. The description fails to explain what the result of 'can be opened' looks like, which parameters are relevant to the main URL check, and how the many unrelated-looking discarded parameters factor into the tool's behavior.

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

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

All nine parameters have descriptions in the schema, so schema description coverage is 100%, which sets the baseline at 3. The tool description itself adds no parameter-level guidance and does not clarify how parameters like city, query, or zone relate to 'checking whether a URL can be opened,' but the schema already provides descriptions for each parameter.

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

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

The description clearly identifies the action—checking whether a URL can be opened—and adds a meaningful qualifier that no browser is launched. This helps distinguish it from browser-launching tools like playwright-url-ok, though it does not explicitly differentiate it from similar URL status tools such as fetch-status or web-fetch.

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

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

There is no guidance about when to use this tool versus siblings like playwright-url-ok, fetch-status, or normalize-url. The phrase 'No browser is launched' is a behavioral hint rather than an explicit routing instruction, so an agent gets little help choosing among the many closely related alternatives listed.

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

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

No annotations are provided, so the description must carry the load for behavioral disclosure. It only adds that the expression is 'discarded', which hints at no retention but says nothing about side effects, return values, permissions, or how the parameters are processed. This is clearly insufficient for a mutation-like tool with no annotations.

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 front-loaded with the intended action and includes no filler or redundancies. Both sentences are purposeful, but the text is so thin that some key information is missing elsewhere. It is concise rather than verbose, which earns it a high but not perfect score.

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

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

With nine optional parameters, no annotations, and no output schema, the single-sentence description leaves the agent unable to infer how to pass an expression, what the response looks like, or why that expression is evaluated. The description is far too sparse to declare the tool safe for autonomous invocation.

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

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

Schema coverage is 100%, so every parameter has its own description, and the baseline is therefore 3. The description does not add any meaning to the parameters; in fact, it introduces a concept ('expression') that has no corresponding parameter. This is a missed opportunity but the schema still provides full parameter documentation.

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

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

The description states a specific action ('Evaluate a+b style arithmetic') but is vague about what resource or input is used, and no schema parameter represents an arithmetic expression. It does not clearly differentiate from the many sibling shape/check tools, since 'Expression discarded' leaves the operation confusing. Overall it has a purpose, but not a crisp one.

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

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

There is no guidance about when to use this tool versus any sibling, no prerequisites, and no exclusion cases. The phrase 'a+b style arithmetic' implies a narrow use case, but without an expression parameter or mention of alternatives, the agent is left with no information about when this tool is a better choice than one of the many 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?

No annotations are provided, so the description carries the full burden. It discloses that page content is not stored, which is a useful behavioral note, but it omits other critical behaviors: whether network requests are made, whether the URL must be HTTPS (though the schema says 'HTTPS URL' in the url parameter), what happens when parameters are 'discarded', and whether the tool handles errors. The description also fails to explain the purpose of the numerous unrelated parameters, leaving the agent with an incomplete picture.

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

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

The description is a single sentence, which is concise. However, it is under-specified; it conveys one core action but omits essential usage details. The sentence is structured with the main function first, which is good, but the lack of other information makes it less effective. It is short but not sufficiently 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, the description is severely incomplete. It does not explain the role of most parameters, how they interact, or what the expected return format is. An agent cannot confidently invoke this tool correctly given the sparse description and the many ambiguous parameters that appear irrelevant to the stated purpose.

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% — every parameter has a description. The tool description adds no additional parameter context. Per the baseline, with high schema coverage, a score of 3 is appropriate. The description does not clarify how parameters like 'city' or 'path' relate to the stated function, but the schema descriptions partially cover their meanings, so the description doesn't need to do more.

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

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

The description states a specific verb and resource: 'Return host, scheme, and HTTP status for a URL.' This is clear and action-oriented. However, it does not distinguish this tool from several sibling tools like fetch-status or normalize-url, which likely perform similar operations. The name 'citation' also has a mismatch with the described function, reducing clarity further.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention any conditions, exclusions, or scenarios where this tool is preferred. With many sibling tools offering overlapping URL functionality, this lack of directional guidance leaves the agent to guess.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It does disclose that identifiers are not retained, which is useful privacy context, but it fails to mention side effects, output format, or how the classification is performed. The parameter descriptions hint at 'discarded after' checks, but the overall behavior remains opaque.

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

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

The description is extremely short, but brevity here comes at the expense of usefulness. It fails to front-load what the tool does or why an agent would call it, and the privacy statement is not enough to make the description memorable or actionable.

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 heterogeneous parameters, no output schema, and no annotations, the description is grossly insufficient. An agent would have no idea what the tool returns or how to interpret the classification result, making correct invocation largely guesswork.

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

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

Schema description coverage is 100%, and each parameter has a meaningful description (e.g., 'discarded after the shape check'). The tool description adds no additional parameter semantics beyond what the schema already provides, so the baseline 3 is appropriate.

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

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

The description says 'Show how this request is classified' but gives no indication of what classification scheme is used or what the output looks like. It is too vague to distinguish from sibling tools like validate-json or file-path-ok, which also take diverse inputs.

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

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

No guidance is given on when to use this tool versus alternatives. With 9 parameters covering a wide range of input types (URLs, JSON, paths, timezones, etc.), it is unclear whether this is a general-purpose classifier or a fallback for when more specific sibling tools don't apply.

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 for behavioral disclosure. It does state the core transformation and the excluded ownership behavior, but it omits details like edge-case handling, error behavior, or whether the tool performs any validation beyond label splitting.

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

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

The description is a single, front-loaded sentence with no wasted words. It states the core operation and the main negative constraint efficiently.

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

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

Given no output schema, no annotations, and 9 optional parameters, this description is too sparse. It does not state which parameter to use, what happens when multiple parameters are supplied, or what the returned labels look like, so an agent cannot confidently operate the tool across its declared input surface.

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

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

Schema description coverage is 100%, and each of the 9 parameters already carries its own explanation, so the description adds little over the schema. It references hostname generally but does not connect the stated purpose to the specific parameter set or clarify how the 9 fields relate to the splitter operation.

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 ('split') and resource ('hostname') and adds a useful negative scope ('without WHOIS or ownership data'). However, the input schema exposes 9 unrelated optional properties, and the description does not explain how those map to the hostname being split.

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

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

There is no explicit guidance about when to choose this tool over sibling tools such as normalize-url or github-repo-shape. 'Without WHOIS or ownership data' hints at scope but does not say when this tool is appropriate or when another shape/URL tool should be used instead.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. It reveals only that it performs a HEAD request and returns status, but does not disclose what happens with the other 8 parameters, whether any state is persisted, or what the actual return format is. The schema's 'discarded' comments are not part of the description.

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

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

The description is a single concise sentence, which is efficient, but it omits essential information for a tool with 9 parameters and no required fields. It is front-loaded with the action but lacks the structure needed to explain the tool's versatility, making it too sparse for the complexity.

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

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

Given 9 parameters, no required fields, no output schema, and no annotation coverage, a one-line description is severely inadequate. It does not explain what inputs are valid, how the tool behaves across different input types, what 'status' means, or what the response looks like. An agent cannot correctly infer how to invoke this tool for anything beyond a simple URL check.

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

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

Schema description coverage is 100%, so each parameter has at least some textual description. The tool description itself adds no parameter meaning, and given the mismatch between the description's URL-only focus and the schema's diverse fields, the semantics of how parameters combine remain unclear. Baseline of 3 is maintained because the schema does document each field.

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 ('HEAD a public URL and return status only'), which is clear for one narrow use case. However, the input schema lists 9 parameters including city, zone, query, json, and path, many unrelated to URLs, so the description fails to convey the tool's actual broader scope and does not distinguish it from siblings 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 gives no guidance on when to use this tool over its many siblings such as browser-url-ok, playwright-url-ok, or domain-shape. It only says 'HEAD a public URL and return status only,' which implies a URL status use case but does not explain prerequisites, exclusions, or alternatives.

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

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

Annotations are completely absent, so the description must carry the behavioral disclosure burden. It only states that a path is discarded, and does not clarify whether this is read-only, what it returns, or what happens to other 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 compact and front-loaded with the main purpose. There is no wasted wording, though it is sparse enough that the second sentence adds more ambiguity than useful context.

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

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

With 9 optional parameters, no annotations, and no output schema, a two-sentence description is not sufficient. It does not indicate which parameters are relevant, what a successful parse yields, or how this relates to other shape/validator tools.

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

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

Schema description coverage is 100%, so the schema already explains each parameter. The description adds 'Path discarded' but does not materially clarify how the 9 parameters relate to Figma URL parsing.

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

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

The description states a concrete action and resource: 'Parse a Figma file URL.' That is enough to distinguish it from sibling tools like github-repo-shape or jira-key-shape, though the phrase 'Path discarded.' is ambiguous and no explicit differentiation is given.

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

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

There is no guidance on when to use this tool versus alternatives, no exclusions, and no mention of required conditions. The only implied usage is 'when you have a Figma file URL,' but the description does not give enough for an agent to route reliably.

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

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

The description discloses that the tool performs no disk access, which is a useful behavioral safe-guard. However, it does not mention what the tool returns (e.g., boolean, error), how it handles unsafe paths, or that it discards all parameters after the check (as evidenced by the schema descriptions). With no annotations, the description carries the full burden of disclosure, and it falls short of explaining side effects, error behavior, or the result shape.

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

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

The description is a single sentence that states the purpose and a key constraint. It is efficient and front-loads the essential information. However, for a tool with nine parameters, the brevity borders on under-specification rather than effective conciseness. It still earns a 4 because every word adds value, but it is not exemplary.

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

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

Given the tool's complexity (nine parameters, no output schema, no annotations), the description is severely incomplete. It provides no information about the tool's return type, the meaning of 'safe', the role of the other parameters, or how the tool should be used relative to the many sibling validators. An agent cannot confidently call this tool correctly based on the description alone.

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

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

Schema description coverage is 100%, so all nine parameters already have individual descriptions. The tool description adds no additional meaning about any parameter—it does not even explicitly name the 'path' parameter. This is a baseline 3 because the schema already covers parameter semantics, but the description provides no extra context that would help the agent understand how the parameters relate 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 clearly states a specific verb and resource: 'Check whether a path looks safe.' It also mentions a key constraint ('No disk access'), which distinguishes it from disk-touching tools. However, the tool's schema accepts eight other parameters (url, city, json, etc.) that the description does not mention, creating ambiguity about the tool's actual scope. The description is clear about the core purpose but not about its applicability to the other parameters.

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

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

The description offers no guidance on when to use this tool versus alternatives. It does not mention any conditions, exclusions, or sibling tools that might be more appropriate for different input types. An agent has to infer that this is for file paths based on the name and description, but there is no explicit direction. This is a significant gap given the large set of sibling validators.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only says 'Latitude and longitude for a place via Open-Meteo,' but does not explain that it makes an external API call, how inputs are handled (many are described in the schema as 'discarded'), or what the response format looks like. The description fails to disclose side effects, failure modes, or the nature of the 'hint' mechanism.

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

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

The description is a single sentence, which is concise and front-loaded with the core purpose. However, it is too sparse for a tool with 9 optional parameters and no other context. Conciseness is achieved at the expense of necessary detail, making it under-specification rather than effective 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?

Given the complexity of the input schema (9 optional parameters), no output schema, and no annotations, the description is extremely incomplete. It does not mention output structure, error behavior, or how to select among the many parameters. An agent cannot reliably invoke this tool correctly without significant 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?

The schema has 100% description coverage, and each parameter has a brief description (e.g., 'City name for a public weather hint; discarded after the call'). However, the tool description does not explain how these parameters relate to the stated purpose of obtaining latitude and longitude. The schema alone does not tell the agent which parameter to use or whether they are mutually exclusive. The description adds no semantic value beyond what the schema provides, and it fails to clarify the primary input.

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

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

The description states that the tool returns latitude and longitude for a place via Open-Meteo, which identifies the core action and resource. However, it does not clarify how the many input parameters relate to obtaining that place, and the name 'geo-hint' suggests a hint or validation role rather than a direct geocoding service. The purpose is too vague to distinguish this from other sibling tools that also handle location or weather data (e.g., weather-hint, timezone).

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention intended use cases, prerequisites, or which scenarios it applies to. With siblings like weather-hint and timezone, an agent cannot determine if geo-hint is the right choice without additional 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?

Annotations are absent, so the description carries the full burden of behavioral disclosure. It says 'parse' but does not state that other parameters (like 'city', 'feed', 'json') are ignored or discarded, nor does it indicate what happens on failure (e.g., returns null or throws). The schema descriptions mention 'discarded' for some params, but the tool description itself provides no behavioral context about the operation's side effects or error handling.

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

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

The description is a single, succinct sentence with no extraneous words. It front-loads the core action clearly. While it lacks depth, it is appropriately concise for a tool that appears to perform a simple extraction, and there is no filler or redundant phrasing.

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

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

Given the tool has 9 parameters and no output schema, the description is incomplete. It does not specify which parameter is used, what the return value looks like (owner and repo in what format), or how the tool behaves with invalid URLs. An agent calling this tool would need to infer that 'url' is the relevant input and would have no information about the result structure, making the description inadequate for effective 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 description coverage is 100%, so the baseline for this dimension is 3. The description does not add meaning beyond the schema—it does not highlight that 'url' is the primary parameter or clarify the role of the other eight parameters. Since the schema already describes each parameter individually, the description fails to compensate for the potential confusion caused by the many unrelated parameters in this small tool.

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

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

The description states a specific verb ('parse') and a specific resource ('GitHub URL'), making the core purpose clear. However, it does not differentiate itself from sibling shape-checking tools like 'domain-shape' or 'jira-key-shape' by mentioning that it validates or extracts a particular shape. The action is unambiguous, but the scope is narrow enough that it could be confused with a general URL parser if not for the GitHub keyword.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention that it is specifically for GitHub URLs, nor does it exclude non-GitHub URLs or explain that only the 'url' parameter is relevant. Without any context about prerequisites, exclusions, or alternative tools, an agent cannot determine when this is the appropriate choice among the many sibling shape checkers.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It reports that stories are counted and titles are discarded, but does not disclose network behavior, expected return format, failure modes, or any 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 extremely concise: one short statement plus a terse qualifier. It is front-loaded with the core action and contains no filler words.

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

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

Despite its simple core purpose, the tool has nine optional parameters and no output schema. The description does not explain which parameters are relevant to counting HN stories, nor what the return value looks like. An agent selecting and invoking this tool would lack essential context.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no semantic information about the nine optional parameters; 'Titles discarded' is the only behavior hint and does not clearly map to a particular parameter.

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

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

The description states a specific verb and resource: count current Hacker News front-page stories. It also clarifies a key aspect of the result with 'Titles discarded.' It is clear in purpose but does not explicitly differentiate itself from sibling tools.

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

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

No guidance is given on when to use this tool versus alternatives. The 'Titles discarded' hint implies it is not for retrieving titles, but there is no explicit when-to-use or when-not-to-use 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?

Since no annotations are provided, the description carries the full burden for behavioral disclosure, but it reveals no behavior. It never says whether the operation is read-only, returns names, changes any state, or fails in particular conditions. This leaves the agent guessing about side effects and expected output.

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?

It is a single, brief sentence with no redundant wording, so it is concise. However, the brevity is under-specification rather than helpful compression: for a 9-parameter tool, the description does not front-load purpose, usage, or any structural guidance.

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

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

There is no output schema and no annotations, so the description must supply the missing context, but it barely does. It leaves unclear what output is returned, which of the 9 arguments are relevant, and what an example call looks like. For a tool with this much ambiguity, the context is incomplete.

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

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

The input schema already covers all nine parameters with individual descriptions, so the parameter_semantics baseline is at 3. The tool description itself adds no meaning about choosing a parameter or how the zone field relates to the other discarded fields.

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

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

The description is a noun phrase that essentially restates the tool name ('IANA timezone names') without a verb or explicit outcome. It does not state whether the tool returns a list, validates zones, or produces a reference value. It adds only a loose 'for clock calls' context, but an agent still cannot tell what invoking it 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?

The only usage hint is 'for clock calls,' which is too vague to guide an agent. It does not explain when to use this tool instead of siblings like timezone or utc-time, nor what kinds of calls it supports. No exclusions, preferences, or alternatives are given.

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

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

There are no annotations, so the description carries the full behavioral transparency burden. It does mention that only group counts are returned, which is a useful output-scope disclosure, but it omits network failure behavior, handling of missing robots.txt files, rate limits, or side effects. This is insufficient for a network-touching tool.

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

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

The single sentence is sharply front-loaded with the explicit action and resource, with no filler or repetition. However, the extreme brevity comes at the expense of disambiguation and parameter guidance, though for pure conciseness it works.

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

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

The tool has no output schema, no annotations, 9 parameters, and 28 siblings with overlapping capabilities. The one-sentence description makes no attempt to explain which parameter is relevant, what the output shape looks like, or how this differs from the many network fetching siblings, making it incomplete for confident use.

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 9 parameters whose descriptions feel unrelated to robots.txt: 'url' is described as 'HTTPS URL to normalize or cite', while others like 'ref', 'city', and 'zone' describe discarded or validation-only values. The tools description adds no mapping between 'robots.txt' and any specific parameter, so an agent cannot reliably know which parameter to populate.

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

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

The description states a concrete verb and resource: 'Fetch a public robots.txt and return group counts only.' This distinguishes it from generic fetching siblings like web-fetch or fetch-status because it targets robots.txt specifically. 'Group counts' is slightly ambiguous, but the main purpose is clear.

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

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

No usage context is given. The description never says when to use this over siblings like web-fetch, fetch-status, browser-url-ok, or normalize-url, and there are no exclusions or prerequisites. An agent is left to infer the appropriate scenario.

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 sentence 'Key discarded' provides one meaningful behavioral trait, and it is consistent with the schema's repeated 'discarded after' notes. But with no annotations and no output schema, the description still carries the burden of explaining result format, error behavior, validation semantics, and side effects, none of which is covered.

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 two lines are front-loaded and free of filler, so the structure is efficient. Still, it is too terse for the task: a single sentence of usage mapping between the Jira key and the applicable parameter would be more valuable and would still remain concise.

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

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

With nine parameters, no annotations, no output schema, and a description that never identifies the relevant parameter or return semantics, the tool definition leaves an agent unable to invoke it correctly. The schema's entirely per-parameter descriptions help, but the orchestration-level knowledge needed is missing.

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

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

Schema description coverage is high (baseline 3), but the tool description does not map the 'Jira issue key' concept to any parameter. The descriptions for ref, url, query, etc. never mention Jira, so an agent cannot tell which field holds the key; the description adds no semantic linkage and creates a likely mismatch.

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

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

The description names a specific verb and resource ('check a Jira issue key shape') and is distinct from sibling shape-checkers such as github-repo-shape and domain-shape. However, the clarity is undermined because none of the nine schema parameters is identifiable as a Jira key, so the stated purpose is not easily actionable from the full definition.

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

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

The description gives no guidance about when to use this tool versus sibling validation tools. It does not exclude other tools, does not describe the conditions that favor this tool, and does not indicate which of the nine input fields should contain the key being inspected.

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 behavioral burden. It discloses nothing about side effects, network access, discarded inputs, or return behavior, leaving the tool's operation completely 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 one short sentence, but it is under-specified rather than concise. It merely echoes the tool name and omits even a single behavioral or contextual detail an agent would need.

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 cannot be adequately described by a four-word phrase. The relationship between the language tag and parameters like 'city', 'feed', or 'json' is completely unexplained, making correct invocation impossible.

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 documents all nine parameters with 100% coverage, so the baseline is 3. The description adds essentially no parameter-level context, so it neither improves nor reduces the schema's contribution.

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

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

The description is a noun phrase, 'ISO 639 language tag zu,' which restates the tool name without an action or resource. It doesn't state whether the tool validates, converts, or returns the tag, and provides no differentiation from the many sibling validation tools.

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

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

The description gives no usage context, alternatives, or exclusions. With nine parameters and a large sibling list, an agent has no basis for deciding when to call lang-zu versus any other tool.

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

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

With no annotations, the description is the sole carrier of behavioral info. It only mentions 'Body discarded,' which hints at a side effect but does not clarify what the tool actually does with the various inputs, what it returns, or any limitations. The mismatch between the description and schema further obscures behavior.

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

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

The description is short and front-loaded with a single sentence, which is structurally concise. However, it is under-specified to the point of being cryptic, and it fails to earn its place by omitting critical scope information. The brevity works against clarity here.

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, zero required, no output schema, and no annotations, the description is almost completely inadequate. It does not explain the tool's core function beyond a narrow example, nor does it cover the variety of inputs listed in the schema. An agent cannot reliably determine what to call this tool with or what to expect back.

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

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

Although schema_description_coverage is 100%, the description adds no meaning to any parameters. It fails to explain why there are nine disparate optional parameters (e.g., 'city' for a weather hint, 'json' for validation, 'path' for file check) under a tool named 'lib-docs-hint.' The schema's own descriptions provide some semantics, but the description does not unify or clarify them, leaving the parameter set confusing.

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 ('HTTP status for a public library docs URL') but this directly conflicts with the input schema, which contains parameters for city, feed, json, path, zone, and query — none of which relate to a library docs URL. The purpose is therefore vague and likely misrepresents the tool's actual scope. It does not distinguish the tool from siblings 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?

No guidance is provided on when to use this tool versus any of the ~27 sibling tools. The description gives no context for when it should be invoked or what distinguishes it from alternatives such as normalize-url, validate-json, or geo-hint.

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. It clearly discloses that values are ignored, which is the key behavioral trait. It does not mention return format, edge cases, or side effects, but for a pure counting operation this is a reasonable disclosure.

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

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

Two short sentences with no filler; the core action is front-loaded. It is concise, though slightly under-specified.

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 and no output schema or annotations, yet the description does not clarify how the parameters relate to the 'JSON object' being counted. It is ambiguous whether the tool counts keys in the input object or in the value of the 'json' parameter. This is a significant gap for correct invocation.

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

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

Schema coverage is 100%, so baseline is 3. The description adds the cross-cutting semantic that all parameter values are discarded, which is not evident from the individual schema descriptions. This helps an agent realize it can pass dummy values.

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

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

The description uses a specific verb ('count') and resource ('keys in a JSON object') and adds a behavioral qualifier ('values discarded'). It is not a tautology and is distinguishable from siblings like validate-json, though it does not explicitly identify the input object as the set of provided parameters.

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

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

The phrase 'values discarded' implies that callers need not supply meaningful values, which is a useful hint. However, it gives no explicit guidance on when to prefer this tool over alternatives or what conditions trigger its use.

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 is the main source of behavioral signal. It does disclose that only origin, host, and path are returned and that query and fragment are dropped. However, it does not mention validation behavior, error handling, or how the several optional schema parameters are treated, leaving meaningful gaps.

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

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

The description is only two sentences, free of filler, and the main behavior is front-loaded. It is concise in a defensible way, though slightly too terse given the complexity of the nine-parameter schema.

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

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

Given nine optional inputs, no output schema, and no annotations, this description is under-specified. It does not explain which parameters are relevant, what the full return shape is beyond three components, or how failures and invalid URLs are handled, which makes it incomplete for confident tool invocation.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description does not explain parameters. The description adds little signal about how 'url' relates to the other eight optional parameters, many of which seem unrelated to normalization, so it does not help an agent decide which parameter to populate.

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

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

The description states a concrete output ('origin, host, and path for a URL') and the transforming behavior ('query and fragment are dropped'). This is clear and specific, though it does not explicitly distinguish the tool from sibling URL-related tools such as browser-url-ok or fetch-status.

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

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

No explicit guidance is provided about when to use this tool versus siblings, nor are any when-not-to-use cases or caveats given. Usage is only implied by the function name and the one-sentence description, which is insufficient for reliable selection among many similar-looking 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 the full behavioral burden. It discloses that no browser is launched, but it does not explain what happens with the many other parameters in the schema, whether the check is read-only, what the return format is, or how the 'discarded' parameters affect behavior. The description also implies a URL-focused tool while the schema includes unrelated parameters, creating ambiguity.

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

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

The description is extremely concise—two sentences, front-loaded with the primary purpose and a key behavioral caveat. Every word earns its place. It lacks additional structure but remains 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?

Given the complexity (9 optional parameters, no annotations, no output schema), the description is severely incomplete. It does not explain what the tool returns, how to select the correct parameter for the URL check, what happens with the other parameters, or any side effects. An agent would be unable to call this tool with confidence.

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

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

Schema coverage is 100% and each parameter has a description, so the baseline is 3. However, the tool description itself does not clarify which parameter is the URL to be checked, and the parameter descriptions (e.g., 'normalize or cite') do not align with the stated purpose of 'opening' a URL. The description adds no value beyond the schema and actually introduces confusion about the tool's scope.

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

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

The description states a clear action and resource: 'Check whether a URL can be opened.' It also adds a distinguishing detail ('No browser is launched') that separates it from browser-centric tools. However, it does not explicitly name any sibling alternatives, so it misses a point for full differentiation.

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 conditions, prerequisites, or exclusions. There is no reference to sibling tools like browser-url-ok or web-fetch, leaving the agent to infer usage.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The only disclosed behavior ('Query. discarded') is redundant with the schema's parameter description ('Search text; discarded after the length check'), so the description adds nothing beyond the structured data. It does not indicate whether a call is purely local, makes network requests, requires auth, or what the side effects for the other 8 parameters are.

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 with no filler; every sentence carries intent. It is slightly under-sized relative to the 9-parameter surface, but the structure itself is clean and non-redundant.

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

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

For a tool with 9 optional parameters and no output schema, the definition is incomplete: it never states which parameters are processed, what the return value is, or whether the other 8 fields are ignored. An agent can infer the query param is counted, but has no basis to decide how to supply hosts, feeds, JSON, and other fields, or what answer to expect.

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. Every parameter already carries its own description in the schema. The description's 'count characters' and 'Query. discarded' echo the query parameter's schema text, adding little semantic value; the other 8 parameters remain unexplained beyond their schema entries.

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 specific verb+resource: count characters in a search query, with an explicit 'discarded' side note distinguishing it from persistent tools. However, it does not differentiate from sibling counting utilities (hn-front-count, memory-key-count) or explain why the schema exposes 8 other parameters when only 'query' seems relevant.

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 whatsoever on when to call this tool versus siblings like memory-key-count, hn-front-count, or the shape/validation tools. There is no mention of alternatives, prerequisites, or when not to use the tool.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. It fails to mention what the tool returns, whether it performs any external calls, has side effects, or how the input parameters are used. The phrase 'discarded after the shape check' in schema descriptions hints at validations, but the tool-level description adds no behavioral context.

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

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

The description is a single vague sentence. While concise in word count, it is under-specified rather than efficiently structured. It does not front-load actionable information and omits essential details about what the tool does with the inputs.

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

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

For a tool with 9 optional parameters and no output schema, the description is severely incomplete. It does not explain the tool's actual behavior, how parameters influence results, or what a caller should expect. The mismatch between the stated purpose (HTTP status codes) and the parameter set further compounds the incompleteness.

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

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

Schema description coverage is 100%, so each parameter has a short description (e.g., 'Git ref name; discarded after the shape check'). This gives some semantics but the tool description adds nothing about how the parameters relate to the stated purpose. Baseline 3 is appropriate since the schema does the work.

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

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

The description says 'Short catalog of common HTTP status codes,' which suggests it returns a reference list. However, the input schema contains 9 unrelated parameters (ref, url, city, feed, etc.) that have no obvious connection to HTTP status codes, making the purpose unclear and potentially misleading. The verb 'catalog' is vague and does not specify what action the tool performs.

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

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

No guidance is provided on when to use this tool versus the many siblings (e.g., `fetch-status`, `browser-url-ok`, `normalize-url`). The description does not mention any context, prerequisites, 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?

With no annotations provided, the description carries the full burden of disclosing behavior. It only says 'Prompt discarded,' which is ambiguous and fails to explain that the parameters are ignored after a shape check. There is no mention of side effects (or lack thereof), permissions, or output nature, so an agent cannot predict what happens beyond a static template.

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

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

The description is very short, but this is under-specification rather than conciseness. It front-loads the template idea but contains no actionable structure or explanation. The 'Prompt discarded' phrase is unnecessary and does not earn its place.

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

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

Despite nine optional parameters and no output schema, the description offers no explanation of what the template looks like, why the parameters exist, or how the tool might be useful. An agent cannot determine when or how to invoke it correctly. The complexity of the schema is not compensated by any descriptive detail.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no meaning beyond the schema; it does not clarify why nine disparate parameters (ref, url, city, feed, etc.) are accepted if they are discarded. It neither reinforces nor contradicts the schema, so it stays at 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 it returns a 'three-step thinking template,' which gives a vague verb-resource pair, but it does not explain what the template contains or how it relates to the tool name. It provides no differentiation from any of the 29 sibling tools, and the phrase 'Prompt discarded' adds confusion rather than clarity.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention any context, prerequisites, or exclusions, leaving the agent to guess entirely from the name and schema.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It only states the output (current time) but does not mention that the tool ignores all parameters except 'zone', nor does it describe return format, DST handling, or error behavior. The inclusion of many unrelated schema parameters (ref, url, city, etc.) without any explanation in the description creates significant ambiguity about what the tool actually does with them.

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

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

The description is a single, compact sentence that immediately conveys the action. It is front-loaded with the core purpose and contains zero filler. This is an exemplary model of concision, even if the content is thin on behavioral details.

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

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

Given 9 parameters, no output schema, and no annotations, this description is severely incomplete. It does not explain return format, timezone handling, or that only 'zone' matters. The schema's unrelated parameters further amplify the need for clarity, which the description fails to provide. An agent would be uncertain about how to invoke the tool correctly and what to expect as 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?

The schema has 100% coverage with descriptions for all parameters, so the baseline is 3. The description adds no parameter-level meaning; it does not highlight that 'zone' is the only relevant parameter for its purpose. While the schema's own description of 'zone' is clear, the presence of many irrelevant parameters is not addressed by the description, potentially misleading the agent. The description fails to add value beyond the schema, hence the baseline score.

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 purpose: returning the current time in a named IANA timezone. The verb 'Current time' and resource 'named IANA timezone' are specific and unambiguously distinguish it from siblings like utc-time and iana-zones. The one-liner is precise and leaves no doubt about the core function.

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

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

The description implies when to use the tool: whenever the current time in a specific IANA timezone is needed. It does not explicitly mention alternatives or exclusions, but the naming and phrasing strongly suggest it is the tool for named timezones, while utc-time is for UTC. This is adequate implicit guidance though not fully explicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says the tool returns a current UTC timestamp, but it does not specify the timestamp format, whether all optional params are ignored, or any safeguard guarantees; an agent is left to infer these details.

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

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

Four-word description, front-loaded and entirely without filler. It earns its place, though other dimensions pay the price for the extreme 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 a simple purpose, the tool has nine optional parameters and no output schema. The description does not reveal the return format, confirm that parameters are ignored, or note the simplest valid invocation (no arguments). The schema is detailed but the overall tool contract remains underspecified.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no meaning beyond that schema: it ignores all nine optional parameters and does not explain or ensure the agent understands their 'discarded' 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 conveys the core resource and result: a current UTC timestamp. It is distinguishable from siblings like `timezone` and `iana-zones`, but it uses a noun phrase rather than an explicit verb (e.g., 'Returns') and never names or differentiates sibling tools.

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

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

No guidance is given about when to use this tool versus alternatives such as `timezone` or `iana-zones`. The name and description imply 'use this for current UTC time,' but there is no explicit routing, exclusions, or example usage.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It does disclose that the body is discarded, but it omits any outcome for invalid JSON, return behavior, error handling, and those schema-level side-effect hints such as 'no disk access' are not carried into 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 very short and front-loaded, which is structurally clean. But for a tool with nine parameters and no output schema, this brevity under-specifies the operation; a genuinely effective description would compensate for its brevity with clarifying examples or parameter mapping.

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

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

Given the nine-parameter schema and the absence of an output schema, the description should at least identify the required input (the `json` field) and state what the result of valid/invalid JSON is. It does neither, leaving the agent to guess how to invoke the tool despite well-described parameters in 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%, which normally warrants a baseline of 3, but the description adds no extra meaning and introduces the unbounded word 'body' rather than mapping to the actual `json` parameter. The per-parameter schema descriptions were not carried here, and the tool description does not help disambiguate why a JSON validator accepts `url`, `city`, `host`, `zone`, and `query`.

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

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

The description uses a concrete verb ('check whether') and a specific object ('a body is valid JSON'), so the core purpose is clear and distinct from the shape-checking sibling tools. However, the description refers to a 'body' while the only matching input property in the schema is named `json`, which creates mapping ambiguity for an agent.

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

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

There is no when-to-use or when-not-to-use guidance, and no alternative tools are mentioned. An agent is not told which parameter holds the 'body' JSON text or how this tool differs from sibling validation tools such as `wiki-title-ok`, `jira-key-shape`, or `github-repo-shape`.

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

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

No annotations are provided, so the description carries the full burden. It only says 'via Open-Meteo', suggesting an external call, but it does not disclose that only 'city' is actually used while the other schema parameters are discarded, nor does it state the output format or that the call is read-only. The schema's parameter descriptions fill some gaps, but the description itself adds too little behavioral context.

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

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

One sentence, no filler, and the key concept (city + current temperature + Open-Meteo) is front-loaded. It earns its place and avoids irrelevant details.

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

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

For a tool with 9 optional parameters and no output schema, the description is not enough. It does not clarify that most parameters are ignored, warns about any default behavior, or describe the typical return. An agent is likely to be confused why 'url' or 'path' appear on a weather tool. The description should at least say 'pass only city; other fields are ignored'.

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%: every parameter has its own description, including 'discarded' notes. The tool description does not add parameter information beyond what the schema provides. It does highlight 'city', which is the meaningful parameter, but overall this is the baseline 3 for full 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 'Current temperature for a city via Open-Meteo' names a specific verb and resource, immediately distinguishing this from siblings like geo-hint or utc-time. It is clear and unambiguous about the data source and the primary input (city).

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 other hint tools or how it relates to siblings like search options. 'Current temperature' implies use for temperature lookups, but there is no explicit when/when-not interaction and no mention of alternatives.

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

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

No annotations are present, so the description carries full burden. It discloses only that the body is discarded, but does not explain that most parameters are 'discarded after shape check' or that the tool may perform non-HTTP checks. Overall behavior is opaque and potentially inconsistent with the claim of fetching a URL.

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, which is efficient, but it omits critical information about the tool's actual scope and parameters. Brevity is achieved at the cost of accuracy and 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 with 9 optional parameters, no output schema, and no annotations, a one-sentence description is grossly insufficient. It does not explain how each parameter is used, what the output format is, or what conditions apply, making it impossible for an agent to invoke it correctly in most scenarios.

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

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

Schema descriptions cover all 9 parameters (100% coverage), so the schema itself documents parameter meaning. However, the tool description adds no parameter-level detail, and the schema descriptions imply shape-check behavior that contradicts the stated HTTP-status purpose, leaving the agent uncertain about how each parameter affects the call.

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

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

The description states a specific action (returning HTTP status and content type for a URL), but the schema exposes 9 unrelated parameters (git ref, city, feed, json, path, zone, query) that imply a multi-purpose shape-check tool, creating ambiguity. It also fails to differentiate from sibling tools like fetch-status 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?

No guidance is provided on when to use this tool versus alternatives. The description does not mention exclusions, prerequisites, or conditions that would select web-fetch over its many 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 carries the full burden of behavioral disclosure. It only notes 'Title discarded after the call,' which is a minor detail. It does not explain return values, side effects (e.g., network access), or what 'exists' entails. The behavior is largely opaque, making it difficult to predict tool outcomes.

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

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

The description is a single sentence, so it is concise without waste. However, it is under-specified for a tool with 9 parameters and no output schema. The brevity is not backed by necessary detail; it reads more as a placeholder than a helpful guide.

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

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

For a tool with 9 parameters, none clearly linked to the stated purpose, and no output schema, the description is woefully incomplete. It fails to explain how to provide the Wikipedia title, what the response looks like, or any constraints. An agent would struggle to call this tool correctly based solely 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?

Although the schema descriptions cover 100% of parameters, they are generic and unrelated to Wikipedia titles (e.g., 'city', 'zone', 'host'). The description does not identify which parameter represents the title (likely 'query' or 'url'), nor does it add any semantic connection between the parameters and the tool's purpose. The description adds no value in clarifying parameter usage, and the schema descriptions are too generic to compensate.

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: 'Check whether a Wikipedia title exists.' This is a specific verb+resource, and the tool name reinforces the purpose. However, it doesn't explicitly differentiate from sibling 'shape' tools or mention which parameter supplies the title, though the core intent 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 use this tool versus alternatives. It does not mention conditions for use, preconditions, or exclusions. The only hint is the tool name and description, but no explicit 'use this when...' guidance is provided, leaving the agent to infer applicability from the name.

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