Five-field cron shape

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

With no annotations, the description must disclose behavioral traits, but it only says 'Returns connection methods' and 'Task text discarded.' It does not state whether the tool is read-only, makes external calls, incurs costs (despite 'pay-per-call'), requires authentication, or has any side effects. This is a significant gap for a tool that likely orchestrates external API access.

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

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

The description is a single, concise sentence that front-loads the core purpose. It avoids redundancy and is efficient, though it sacrifices necessary detail for brevity.

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

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

For a tool with 9 optional parameters, no output schema, and no annotations, the description is grossly incomplete. It does not explain what 'connection methods' looks like, how to interpret the response, what the parameters do in the gateway selection, or any constraints. An agent would struggle to use this correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning beyond the schema; it does not explain how each parameter relates to finding a gateway or which parameter indicates the task type. The schema itself is unhelpful (most fields are 'discarded after check'), so the description fails 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 states a specific verb and resource ('Find a public pay-per-call tool gateway') and lists example tasks (weather, search, scrape, voice). However, it does not clarify how the task is specified—none of the 9 parameters are named 'task' and several are explicitly discarded. This ambiguity weakens the clarity, making it distinguishable from siblings only by the gateway concept, not by input handling.

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 general context (tasks like weather, search, scrape, voice) but provides no guidance on when to use this tool versus the many siblings (e.g., weather-hint, search-query-len). There is no mention of alternatives or exclusion criteria, so an agent cannot decide between this and other 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 behavioral disclosure. It only states that no browser is launched, but does not clarify whether the tool makes network requests, what it does on failure, whether it is read-only, or any side effects. For a tool that checks URL openability, this is a significant omission.

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

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

The description is extremely concise—two short clauses—and front-loads the core purpose. It earns a 4 for efficiency because every word contributes, and it avoids unnecessary filler. However, it could be slightly more informative without losing conciseness, which is why it is not a 5.

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 with disparate topics (weather, timezone, JSON, file path, etc.) and no output schema—the description is severely incomplete. It does not explain how these parameters are used, what the tool returns, or how the URL check interacts with the other inputs. 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?

The input schema has 100% coverage with descriptions for all nine parameters, so the baseline is 3. The tool description itself adds no parameter-specific information; it does not explain how parameters like 'city', 'zone', or 'json' relate to URL checking. Since the schema already documents them adequately, the description does not need to repeat, but it also does not add value beyond the schema.

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

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

The description states a specific action ('Check whether a URL can be opened') and a key caveat ('No browser is launched'), but the phrase 'can be opened' is vague—it could mean HTTP reachability, DNS resolution, or URL format validity. It also does not differentiate from siblings like 'fetch-status' or 'playwright-url-ok', which similarly deal with URL reachability, leaving an agent unsure which tool to choose.

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

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

There is no guidance on when to use this tool versus the many siblings. The description does not mention alternatives, prerequisites, or exclusion criteria. An agent has no information about when a lightweight check is preferred over a full fetch or browser launch, so usage is left entirely to inference.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. It only says 'Expression discarded,' which is ambiguous and does not explain what the tool does with the provided parameters, what side effects occur, or what the return value is. This is inadequate.

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

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

The description is extremely short, but it is under-specified rather than concise. It omits essential information about the tool's behavior and parameters, making it more confusing than helpful.

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

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

For a tool with 9 optional parameters and no output schema, the description is grossly incomplete. It does not explain how parameters are used, what the tool returns, or what 'discarded' means in practice. This is far below the minimum viable standard.

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

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

Although the schema has 100% coverage for parameter descriptions, the tool description adds no value beyond them. It mentions 'expression' but none of the schema parameters represent an arithmetic expression, so the description does not clarify how the parameters are used or how they relate to the stated purpose.

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

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

The description states 'Evaluate a+b style arithmetic' which gives a basic purpose, but it does not connect to the actual parameters (url, city, json, etc.). The description is vague and does not clarify how the tool operates given the schema, nor does it distinguish from sibling tools like validate-json 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 guidance is provided on when to use this tool versus alternatives. The description does not mention context, prerequisites, or exclusions, leaving the agent with no basis for tool selection.

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

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

With no annotations, the description must disclose behavioral traits. It does state 'Page content is not stored,' which is a useful privacy note. However, it fails to explain side effects, network behavior, rate limits, or how the 'discarded' parameters behave in practice. Many parameters are described as 'discarded after the check,' implying they have no lasting effect, but this is not aggregated or clarified. The description is far from sufficient for a tool with this many behaviors.

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

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

The description is a single, front-loaded sentence that immediately states the primary function and a key behavioral caveat. It is concise and to the point. However, it is so brief that it omits essential context about the broader parameter set, making it under-specified rather than efficiently concise. It earns a 4 for structure but not a 5 because it sacrifices completeness for brevity.

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

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

Given the tool's complexity (9 parameters, no output schema, and no annotations), the description is grossly incomplete. It does not explain what happens when non-URL parameters are provided, what the return value looks like for those cases, or how the tool differs from its many siblings. An agent cannot safely call this tool correctly for anything beyond the URL case. The absence of an output schema places a heavier burden on the description, which it fails to meet.

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

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

Schema description coverage is 100%, so each parameter already has a description. The tool description adds no value beyond the schema, not even a summary of the parameter groups or which one to provide. Since the schema covers all parameters, the baseline is 3, but the description could have enhanced understanding by explaining how parameters relate to the main purpose (e.g., that each triggers a different check). It doesn't, so a 3 is fair.

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 actionable. However, it doesn't differentiate from sibling tools like fetch-status or normalize-url, and it ignores the nine optional parameters in the schema, making the tool's full purpose ambiguous. The single-sentence focus on URL checking suggests a narrower scope than the schema implies.

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

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

No guidance is given on when to use this tool versus siblings such as fetch-status, normalize-url, or web-fetch. The description does not mention any conditions, prerequisites, or alternatives, leaving the agent to guess which tool fits a given task. With 27 sibling tools, explicit routing is essential.

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 'No identifiers are retained,' which is a privacy guarantee, but it does not state whether the operation is read-only, whether it has side effects, or any other behavioral traits (e.g., rate limits, required auth). The privacy note is a plus, but it is insufficient for a tool with zero annotation coverage.

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

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

The description is two sentences, front-loaded with the primary purpose and followed by a privacy note. It is concise and avoids redundancy. However, the brevity borders on under-specification for a 9-parameter tool, though the conciseness dimension rewards efficiency over 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?

The tool has 9 optional parameters, no output schema, and no annotations. The description does not explain how the parameters are used in classification, what the output format is, or what the tool returns. An agent cannot infer correct usage or expected results from the description alone. This is a significant gap for a tool of this complexity.

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

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

The input schema provides 100% description coverage for all 9 parameters, each with a meaningful explanation (e.g., 'Git ref name; discarded after the shape check'). The description text itself adds no parameter-specific meaning beyond the schema. Per the rubric, baseline 3 is appropriate when schema coverage is high.

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

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

The description 'Show how this request is classified' is vague. It does not state a clear verb+resource (e.g., 'classify' vs 'show') or explain what classification means. It does not differentiate from siblings like validate-json or domain-shape, which also analyze inputs. The term 'request' is ambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any sibling tools, use cases, or exclusion conditions. An agent has no basis for selecting this tool over others.

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

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

Without annotations, the description provides minimal transparency. Some parameter descriptions mention 'discarded after the shape check', implying a read-only operation, but it is not consistent across all parameters and no side effects or data handling are explained.

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 with only five words, but it lacks structure and does not effectively convey the tool's purpose. It is short but at the cost of clarity.

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

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

The description is far from complete. It does not explain how the nine optional parameters are used, what the tool returns, or what 'shape' validation entails. Given the complexity, the description is critically insufficient.

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

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

Although each parameter has a description, they are generic and unrelated to cron. For example, 'Git ref name; discarded after the shape check' does not clarify how it relates to a five-field cron shape. The descriptions add no meaningful semantic value.

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

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

The description 'Five-field cron shape' hints at validating a cron expression but does not specify which parameter holds the cron string or what constitutes a valid shape. It is too vague to understand the tool's actual 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?

No guidance is provided on when to use this tool versus sibling tools like 'browser-url-ok' or 'file-path-ok'. The description does not mention alternatives or specific use cases.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose whether the operation is read-only, pure computation, or involves network calls. The only behavioral trait mentioned is the absence of WHOIS/ownership data, which is insufficient for full transparency.

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

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

The description is a single, concise sentence that directly states the tool's purpose and limitation. It has no unnecessary words or filler.

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

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

The description is incomplete relative to the schema complexity. With 9 optional parameters and no required ones, it does not explain how the parameters relate to the 'hostname' operation, leaving ambiguity about which parameter is the actual input. The mismatch between the narrow description and the broad schema makes the context insufficient.

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

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

The description does not map the operation to any specific parameter. Although the schema includes a 'host' parameter described as 'Public hostname,' the description never mentions it, nor does it clarify that the other eight parameters are irrelevant. The schema coverage is 100%, but the description adds little semantic meaning beyond the schema.

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

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

The description clearly states the tool's function: 'Split a hostname into labels' — a specific verb (split) and resource (hostname). It also distinguishes itself from other tools by noting 'without WHOIS or ownership data,' which prevents confusion with domain-info 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 provides a negative usage hint ('without WHOIS or ownership data') indicating when not to use the tool, but it does not explicitly name alternative tools or state when to use this one over siblings. Guidance is implied rather than explicit.

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

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

With no annotations, the description must carry the behavioral burden. It discloses that it performs a HEAD request (read-only) and returns only status, but it does not explain what happens with the other parameters, whether it follows redirects, handles timeouts, or has side effects. The schema descriptions mention parameters being 'discarded,' but that information is not in the tool description, so an agent cannot infer the full behavior.

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

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

The description is a single, front-loaded sentence with no wasted words. It efficiently states the core action and output. However, it is arguably too terse given the tool's complexity, as it omits the broader purpose. Still, for what it conveys, it is concise and well-structured.

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

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

The tool has 9 parameters, no output schema, and no annotations, yet the description explains only one use case (URL status). It does not cover the other 8 parameters, the return format beyond 'status only,' or any edge cases. An agent cannot determine how to use this tool correctly for non-URL inputs or what statuses are returned. This is severely incomplete for a tool of this complexity.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add any meaning beyond the schema; it only mentions 'URL' and 'status' without detailing any parameter. Since the schema already documents each parameter thoroughly, the description's lack of parameter info is acceptable, but it also does not synthesize or clarify the relationships among parameters.

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

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

The description states a specific action ('HEAD a public URL') and output ('status only'), which is clear for the URL case. However, the input schema contains 8 other parameters (ref, city, feed, host, json, path, zone, query) that are not URLs, so the description does not reflect the tool's full scope. It does not distinguish from siblings like browser-url-ok or web-fetch beyond the HEAD method.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention when to prefer it over browser-url-ok, normalize-url, or web-fetch, nor does it state any exclusions or prerequisites. The only implicit signal is the HEAD method, but no explicit comparison is provided.

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. It only mentions 'Path discarded,' but does not disclose whether the tool makes network calls, what it returns, or any side effects. This is insufficient for a tool with 9 parameters.

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

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

The description is one short sentence with no filler, front-loading the core action. However, it is so brief that it leaves major questions unanswered.

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

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

The tool has 9 parameters and no output schema, so the description should explain which parameters are relevant and what the tool returns. It only discusses the URL and discarding the path, leaving the other 8 parameters unexplained and the output unspecified.

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

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

The schema provides descriptions for all 9 parameters (100% coverage), so the baseline is 3. The description adds no additional parameter context, so it does not improve on the schema.

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

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

The description states a specific verb ('Parse') and resource ('Figma file URL'), and notes that the path is discarded. This distinguishes it from sibling tools like domain-shape or github-repo-shape, though it doesn't specify what 'parse' yields.

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

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

No guidance on when to use this tool versus alternatives like normalize-url or browser-url-ok. The description does not mention any conditions or exclusions.

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

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

The description discloses that 'No disk access' occurs, which is a useful safety hint. However, it does not reveal what happens with the other parameters (e.g., whether url or city are validated or discarded) or the return format. With no annotations, the description carries the burden but only partially fulfills it.

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

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

The description is a single, concise sentence with no waste. However, it is under-specified, omitting the tool's broader parameter scope. It is not overly verbose, but the brevity comes at the cost of essential information.

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

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

With 9 parameters, no output schema, and no annotations, the description is severely incomplete. It only addresses 'path' and leaves the other eight parameters unexplained, so an agent cannot infer what the tool does with url, city, feed, or json. This is a significant gap for a multi-purpose validator.

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

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

Schema description coverage is 100%, so each parameter already has a meaningful description. The tool description adds no extra meaning beyond the schema; it only references 'path' and ignores the other eight parameters. Since the schema covers them, 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 states a clear verb and resource: 'Check whether a path looks safe.' However, the input schema reveals 8 other parameters (url, city, feed, etc.) that are not mentioned, making the actual scope ambiguous. It also does not differentiate from sibling tools that perform shape checks (e.g., browser-url-ok, domain-shape).

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

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

No guidance is given on when to use this tool versus alternatives. The description offers no context for selecting this tool over siblings like browser-url-ok or domain-shape, nor does it mention any exclusions or prerequisites.

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 fails to state that only the 'city' parameter is likely used, that other parameters are ignored, that a network call is made, or what the output format is. The phrase 'via Open-Meteo' hints at a service but gives no operational detail.

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

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

The description is a single short sentence with no extraneous words, so it is concise. However, it lacks structure and front-loading—it doesn't highlight the key parameter or usage context, making it too minimal to be genuinely helpful.

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

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

With 9 parameters, no output schema, and no annotations, the description is severely incomplete. It doesn't specify the output format, which parameter is required, how the other parameters affect behavior, or any prerequisites. An agent cannot reliably call this tool correctly based on the given information.

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

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

Schema coverage is 100% but the parameter descriptions are misleading relative to the tool's purpose. For example, 'city' is described as 'City name for a public weather hint; discarded after the call', which suggests a weather-related hint rather than geocoding. The tool description adds no clarification about which parameter maps to the place, leaving the agent confused about how to invoke it correctly.

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

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

The description clearly states the tool returns latitude and longitude for a place via Open-Meteo, distinguishing it from siblings like weather-hint or timezone. However, the input schema includes many unrelated parameters (ref, url, feed, etc.) that muddy the intended purpose, leaving ambiguity about which input actually drives the geocoding.

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 description doesn't mention that it's for geocoding city names, nor does it exclude other tools like weather-hint or timezone. The agent must infer usage from the name and vague description.

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

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

Annotations are absent, so the description carries the full burden of behavioral disclosure. The description only says 'parse' without stating whether it performs network access, how it handles invalid URLs, or whether it discards other input parameters (though the schema hints at 'discarded' for some). No mention of errors, side effects, or return format.

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

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

The description is extremely concise (a single short sentence), which is positive, but it lacks structure and essential context. It does not front-load key information like the output (owner/repo) or the fact that only the URL is used. It is under-specified rather than effectively 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?

Given the tool has 9 parameters and no output schema, the description is inadequate. It does not explain what the tool returns (owner and repo pair), how to interpret success/failure, or that it ignores most parameters. The description is too minimal for an agent to correctly invoke the tool without additional assumptions.

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

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

While schema description coverage is 100%, the tool description adds no value beyond the schema. It does not clarify that only the 'url' parameter is relevant, and the presence of 8 unrelated parameters (ref, city, feed, etc.) is misleading. The description could have stated that other fields are ignored, but it doesn't, leaving agents unsure which parameters matter.

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 resource ('owner and repo from a GitHub URL'), which clearly distinguishes it from URL-checking siblings like browser-url-ok or normalize-url. However, the input schema includes many unrelated parameters (city, feed, json, etc.) that are not mentioned in the description, creating potential confusion about the tool's actual scope.

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

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

The description provides no guidance on when to use this tool versus alternative URL-related tools. It does not mention scenarios where parsing owner/repo is needed, nor does it exclude cases like non-GitHub URLs or redirects. No alternatives or exclusions 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?

No annotations are provided, so the description carries the full burden of disclosing behavior. It only states 'Count current Hacker News front-page stories' and 'Titles discarded,' which is insufficient. It does not clarify whether this is a read-only operation, what data is accessed, what the return value looks like, or any side effects. The phrase 'Titles discarded' is ambiguous and not explained.

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. It is not overly verbose, but it is under-specified. The second sentence 'Titles discarded' is cryptic and does not earn its place as it adds confusion rather than clarity. The structure is front-loaded with the main action, but the overall brevity borders on insufficient.

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

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

Given the tool has 9 parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain what the tool does with these parameters, what it returns, or how to interpret the result. An agent cannot correctly invoke this tool based on the description alone. It lacks essential context about the counting behavior, the meaning of 'Titles discarded', and any constraints on input.

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%, but the parameter descriptions are generic and appear unrelated to the tool's stated purpose (e.g., 'Git ref name; discarded after the shape check', 'City name for a public weather hint'). The tool description adds no meaning to these parameters, and the mismatch between the tool's purpose and the schema descriptions is confusing. The description fails to explain how any parameter affects the counting 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 (count) and the resource (current Hacker News front-page stories), making the primary purpose unambiguous. However, it does not differentiate from sibling tools like 'web-fetch' or 'fetch-status', and the phrase 'Titles discarded' is cryptic, slightly obscuring the intended outcome.

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, prerequisites, or exclusions. An agent has no information about when counting HN stories is appropriate or how it differs from similar operations.

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 must disclose behavior. It does not mention whether the tool performs network calls, returns data, or has side effects. The schema notes that many parameters are 'discarded', but the 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 short sentence, which is concise, but it is under-specified to the point of being unhelpful. It does not front-load key information or structure the purpose for an agent.

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

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

With 9 parameters and no output schema, the description is grossly incomplete. It does not state what the tool returns, how parameters are used, or when to invoke it. An agent cannot correctly call this tool based on the provided description.

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

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

Schema description coverage is 100%, but the description adds no meaning to the parameters. It fails to explain why a timezone tool accepts parameters like 'url' or 'json', and does not clarify which parameter is central. The schema descriptions themselves are inconsistent with the tool's apparent purpose.

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

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

The description 'Common IANA timezone names for clock calls' hints at a timezone-related purpose but lacks a verb or clear operation (does it list, validate, or retrieve names?). It does not distinguish from siblings like 'timezone' or 'utc-time', and the parameter schema includes unrelated fields (url, json, path) that confuse rather than clarify.

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

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

There is no guidance on when to use this tool versus alternatives such as 'timezone' or 'geo-hint'. No context, exclusions, or conditions are provided.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the tool fetches a public robots.txt and returns group counts, but does not disclose that many parameters (ref, city, json, query, etc.) are effectively ignored or discarded, as hinted in the schema. It also does not clarify error behavior, redirects, or what 'group counts' means. This is a significant gap for a tool with 9 parameters and no other metadata.

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, but it is under-specified. It lacks front-loading of key usage details, such as which parameter identifies the robots.txt URL. The brevity is not effective because it omits essential operational context; it reads more like a stub than a guidance note.

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

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

The tool has 9 optional parameters, no output schema, and no annotations, yet the description is just one sentence. It does not explain which parameter drives the robots.txt fetch, what 'group counts' means, or how the other parameters are used (or ignored). For a tool with this complexity, the description is inadequate for an agent to call it correctly without additional context.

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

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

Schema description coverage is 100%, so each parameter has an individual description in the schema. The tool description adds no extra meaning about how parameters relate to the tool's purpose—for instance, it does not specify that 'url' or 'host' is the primary input for the robots.txt fetch. Baseline 3 applies because the schema is complete, but the description fails to clarify parameter roles, leaving the mapping ambiguous.

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 ('Fetch'), a clear resource ('a public robots.txt'), and the output scope ('return group counts only'). This makes the tool's core function evident. However, it does not differentiate from sibling tools like web-fetch or fetch-status, which also fetch URLs, though the robots.txt specificity is a distinguishing factor.

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

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

The description gives no guidance on when to use this tool versus alternatives such as web-fetch, fetch-status, or normalize-url. There is no mention of prerequisites, edge cases, or when the tool is preferred. The agent is left to infer usage from the name and description alone.

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

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

No annotations are provided, so the description must carry the behavioral burden. It only states 'Key discarded,' which is a minor disclosure about data handling, but it does not explain what constitutes a valid key, whether it returns a boolean, throws errors, or performs any side effects. The behavioral profile is essentially absent.

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

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

The description is extremely concise: two short sentences with no waste. The purpose is front-loaded. However, it is so brief that it sacrifices essential context, so it is concise but not necessarily well-structured for a complex tool.

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

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

For a tool with 9 optional parameters, no output schema, and no annotations, the description is grossly incomplete. It does not explain the expected input format, the validation rules, the return value, or any error behavior. An agent cannot reliably call this tool based on the description alone.

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

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

Schema description coverage is 100%, so the baseline is 3. However, the description adds no parameter-specific meaning and fails to identify which parameter is the Jira key. The schema descriptions themselves are generic and unrelated to Jira keys, so the agent cannot determine which input to use. The description does not compensate for this gap.

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

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

The description clearly states the tool checks a Jira issue key shape, which is a specific verb+resource and distinguishes it from sibling shape-checkers like github-repo-shape or domain-shape. However, the connection to the 9 generic parameters is unclear, which slightly muddies the purpose.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention when a Jira key check is appropriate, nor does it reference any sibling tool or exclusion criteria. An agent has no idea if this is the right tool for a given task.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. It only states 'Body discarded,' which is minimal. It does not clarify that a network request is made, any side effects, rate limits, or why many parameters exist. This is a significant gap for a tool that appears to perform network I/O.

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 terse (one sentence) but lacks structure. It does not front-load the essential scope or list the parameter semantics. While concise, it omits critical information, making it under-specified rather than efficiently structured.

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

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

Given 9 parameters, no annotations, and no output schema, the description is woefully incomplete. It does not explain the tool's behavior with most parameters, nor what the expected output format is beyond 'HTTP status.' An agent cannot reliably invoke this tool correctly based on the provided information.

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

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

The schema covers 100% of parameters with individual descriptions, so the baseline is 3. However, the tool description adds nothing to clarify the parameters and actually misleads by implying only a URL is relevant. The description fails to explain why parameters like city, zone, or query exist, adding confusion rather than semantic value.

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

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

The description states it returns HTTP status for a 'public library docs URL' and notes body is discarded, but the input schema contains 9 unrelated parameters (city, feed, zone, etc.) that are not explained. This creates ambiguity about the tool's actual scope and fails to distinguish it 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 about when to use this tool versus alternatives. The description does not mention any conditions, exclusions, or sibling tools, leaving the agent to guess based on the vague name.

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

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

With no annotations, the description carries the full behavioral burden; 'Values discarded' does add transparency about side-effect-free handling. However, it does not disclose the return shape, error behavior for malformed input, or whether nested keys are counted, so it is only minimally transparent.

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 operation and the key behavioral point are front-loaded. It is slightly too terse to resolve the input ambiguity, so it loses a point.

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

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

The tool has nine optional parameters, no required fields, no output schema, and no annotations. The description does not explain which JSON object is being counted, what a successful call should include, or what the result looks like, leaving a high-complexity definition under-specified.

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 the important caveat that parameter values are irrelevant, but it does not clarify the role of the `json` parameter or any other field. Because of the ambiguity among nine optional parameters, this is a baseline-level 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 states a specific action and resource: count keys in a JSON object, and the second sentence clarifies that values are ignored. This is distinct from sibling validators like validate-json or fetch-status, but it does not explicitly identify which input parameter or object is the target, so it stops short of a 5.

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

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

No when-to-use or when-not-to-use guidance is given, and no sibling alternatives are named. The tool's role among the many siblings, such as validate-json or search-query-len, is left entirely to inference.

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

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

With no annotations, the description must disclose all behavioral traits. It mentions dropping query and fragment, but fails to explain that other parameters are 'discarded after a shape check' as the schema implies, or how invalid URLs are handled. The description under-represents the tool's multi-purpose behavior.

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

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

The description is a single, front-loaded sentence with no fluff. It states the core action and the dropped components efficiently. However, it could benefit from a brief note about the other parameters to align with the 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 9 optional parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain the return format (object, string, list), how to handle the non-URL parameters, or what happens when multiple parameters are passed. An agent cannot reliably use this tool beyond the trivial URL case.

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 9 parameters have descriptions. The tool description adds no value beyond the schema for parameter meaning and does not clarify which parameter (e.g., 'url') is the primary one for normalization. Baseline 3 is appropriate since the schema already documents parameters.

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

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

The description clearly states the action for a URL: return origin, host, and path, and drop query/fragment. However, it ignores the 9-parameter schema that includes many unrelated inputs (city, feed, json, zone, etc.), making the tool's actual scope ambiguous. It does not differentiate from sibling shape-checking tools like domain-shape or figma-url-shape.

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

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

No guidance is given on when to use this tool versus siblings such as domain-shape, browser-url-ok, or playwright-url-ok. The description does not state use cases, exclusions, or alternatives, leaving the agent to infer selection.

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

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

With no annotations, the description carries the full burden. It discloses that no browser is launched, which is a useful behavioral trait, but it omits other crucial behaviors: what happens to the input (e.g., network requests, local processing), whether it is read-only, or what side effects occur. The parameter descriptions in the schema mention 'discarded' for some fields, but that is not surfaced in the tool description.

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

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

The description is a single sentence, which is concise and front-loaded with the main action. However, it is so minimal that it fails to convey important context. It is not overly verbose, but it under-specifies, making the conciseness less beneficial than it could be.

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

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

The tool has 9 parameters, none required, and no output schema. The description does not explain what the tool returns (e.g., boolean, status object), how to interpret the result, or how the parameters interact. It is far from complete for a tool with this complexity and no structured output specification.

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

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

Schema coverage is 100%, so the schema already documents all nine parameters with descriptive text (e.g., 'discarded after the shape check', 'titles discarded'). The description itself adds no parameter-level meaning beyond the schema, 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 states a clear verb ('Check') and resource ('whether a URL can be opened'), and adds a key differentiator ('No browser is launched') that sets it apart from siblings like browser-url-ok. However, it does not specify what 'can be opened' means precisely (e.g., HTTP status, reachability, validity), leaving some ambiguity.

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

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

No guidance is provided on when to use this tool versus alternatives such as browser-url-ok, fetch-status, or normalize-url. The description does not mention any conditions, exclusions, or preferred scenarios, so an agent has no basis for selecting it over siblings.

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

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

The description explicitly states that the query is discarded, and the schema descriptions for other parameters also mention they are discarded after checks. This makes the side effects transparent even without annotations, though the full behavior for all parameters is not consolidated in the tool description.

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

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

Extremely concise with only two short sentences. No superfluous wording, and the core function is communicated directly.

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

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

The description does not specify the return value or output format (e.g., whether it returns a number or a string), and it does not explain how the extra schema parameters fit into the operation. Given the tool's simplicity, these omissions make the description 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 tool description adds minimal meaning beyond the schema; it only reinforces that the query is counted. The schema contains many extraneous parameters that are not explained in the description, causing confusion about their purpose or why they exist in a query-length tool. The description does not clarify that only 'query' is relevant.

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

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

The description clearly states the tool counts characters in a search query and discards it, giving a specific verb and resource. However, the presence of many seemingly irrelevant parameters in the schema creates some ambiguity about the actual scope, so it is not a perfect 5.

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

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

No indication of when to use this tool versus alternatives like other sibling count tools. The description lacks any contextual guidance for selection, leaving the agent to infer applicability solely from the name and brief text.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Short catalog' and gives no information about side effects, permissions, or how the parameters affect behavior. The parameter descriptions hint at discarding values after checks, but the tool's actual behavior is 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 short and front-loaded, but it is under-specified rather than concise. A single sentence with no elaboration is adequate for trivial tools, but given the complexity of the schema, it does not earn a higher score.

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

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

For a tool with 9 optional parameters, no output schema, and no annotations, this description is woefully incomplete. It fails to explain what the tool does with the parameters, what it returns, or when it should be used, making it impossible for an agent to invoke it correctly.

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

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

The schema descriptions cover all nine parameters (100% coverage), but the tool description adds no extra meaning. The parameter descriptions are generic (e.g., 'discarded after the shape check') and do not explain how they relate to HTTP status codes. The description does not compensate for the lack of clarity in the schema.

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

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

The description states a specific resource (HTTP status codes) and a verb (catalog), but the input schema's nine parameters (city, url, host, zone, query, etc.) are unrelated to status codes, creating confusion. It does not clarify how these parameters are used, and it fails to distinguish this 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?

There is no guidance on when to use this tool versus alternatives. The sibling list includes many shape-check and validation tools, but the description provides no conditions or exclusions, leaving the agent to guess when this catalog is appropriate.

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

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

The phrase 'Prompt discarded' discloses that input is ignored, which is a behavioral trait not captured by annotations (none provided). However, it does not describe side effects, return format, or other operational details, leaving significant burden unmet.

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

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

The description is extremely concise—two short sentences with no filler. It front-loads the core function, though the brevity borders on under-specification rather than optimal conciseness.

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

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

For a simple template-generating tool, the description provides the essential function, but it omits what the template looks like and when to use it. Given the large sibling set, more context on selection criteria would improve completeness.

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

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

Schema coverage is 100%, with each of the 9 optional parameters explicitly described as 'discarded' or 'checked' in the schema itself. The description adds no additional meaning about parameters, so the baseline of 3 applies.

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

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

The description states a specific verb ('Return') and resource ('three-step thinking template'), making the tool's purpose clear. It is distinct from sibling tools like calc-eval or timezone, which perform concrete operations, though 'three-step' is left undefined.

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 any conditions, prerequisites, or exclusions, leaving the agent to infer its applicability from the name alone.

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

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

With no annotations, the description bears the full burden of disclosing behavior. It only says 'Current time' and offers no information about the return format, side effects, or how the many other parameters are handled (e.g., that they are discarded). This is extremely opaque, especially given the parameter descriptions mention 'discarded after the shape check' but the tool description does not.

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

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

The description is a single short sentence, which is efficient in wording, but it is under-specified for a tool with nine parameters and unclear scope. This is under-specification, not conciseness, because critical information about the tool's full behavior is missing.

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

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

The tool has nine parameters, no annotations, and no output schema, so the description must be comprehensive to be usable. It fails to explain the purpose of the non-timezone parameters, lacks any usage context, and says nothing about the output. The description is grossly incomplete for the tool's complexity.

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

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

Schema description coverage is 100%, so the schema itself documents all parameters, including their disposal behavior. The description adds no parameter-level meaning beyond the schema, so it remains at the baseline of 3. It neither helps nor harms.

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: get the current time for a named IANA timezone. However, it fails to differentiate from the sibling tool 'utc-time' and does not account for the nine unrelated parameters in the schema, leaving the tool's actual scope ambiguous. The verb-resource is clear but the overall purpose is muddied by the schema mismatch.

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

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

There is no guidance on when to use this tool versus alternatives like 'utc-time' for UTC or 'iana-zones' for listing zones. No conditions, prerequisites, or exclusions are provided, so an agent has no basis to choose this tool over siblings.

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

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

With no annotations, the description carries the full burden. It only says 'Current UTC timestamp' and does not disclose that all input parameters are discarded (as the schema notes). The tool's actual behavior—that it ignores all arguments—is hidden, which is a significant transparency gap.

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

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

The description is a single short sentence, which is concise, but it is under-specified. It does not front-load any critical context such as parameter handling or return format. It is more under-specification than efficient 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 9 optional parameters, no output schema, and no annotations, the description is completely inadequate. It omits return format, parameter behavior, and any usage guidance. An agent cannot safely invoke this tool without further inspection of the schema, and even then the purpose remains unclear.

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

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

Schema coverage is 100%, but the description adds no meaning. The parameters are documented in the schema with 'discarded' notes, yet the description does not tie them to the tool's purpose. The mismatch between a time-returning tool and parameters like 'url' or 'json' is confusing, and the description does not resolve it.

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

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

The description states a specific action: returns the current UTC timestamp. However, it does not explain the 9 unrelated optional parameters (ref, url, city, etc.), which creates confusion about the tool's true scope. It also does not differentiate from siblings like 'timezone' or 'iana-zones'.

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

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

No guidance on when to use this tool versus alternatives. There is no mention of use cases, prerequisites, or exclusions. An agent cannot determine whether to pick this over 'timezone' or 'iana-zones'.

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 the body is discarded, but does not state whether the tool is read-only, what it returns (e.g., boolean or status), or whether it makes any network calls. This is insufficient for an unannotated tool.

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

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

The description is a single sentence, efficient and front-loaded with the core action. No redundant wording. However, it is so brief that it sacrifices necessary detail, though that is a completeness issue rather than a conciseness one.

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

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

With 9 parameters, none required, no output schema, and no annotations, the description is far too thin. It fails to explain which parameter to pass, what the tool returns, or any side effects. The schema provides parameter details but the tool's overall behavior remains ambiguous.

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

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

Schema coverage is 100%, so the schema already describes each parameter, including 'json' as 'JSON text to validate'. The description adds no parameter-level meaning, but the baseline is 3 given full schema coverage. The description does not clarify which parameter is the 'body', but the schema provides that information.

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 ('Check whether a body is valid JSON') but the term 'body' is vague and doesn't explicitly map to the 'json' parameter. It distinguishes the tool from siblings only by the name, not by the description. The description provides a basic purpose but lacks specificity about which input to use.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention any sibling tools, use cases, or exclusions. An agent has no information to decide between validate-json and other shape-check tools like github-repo-shape or domain-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?

With no annotations provided, the description must fully disclose behavior. It only mentions a temperature lookup and fails to mention that many parameters are 'discarded after' checks (as noted in schema descriptions), that the tool likely performs multiple validations, or that it may have side effects beyond a simple read. The description is not transparent about the tool's actual operational breadth.

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 is under-specified and omits critical information about the tool's multi-purpose nature. It is not front-loaded with the most useful guidance; instead, it presents a narrow view that could mislead. While brevity is a plus, the lack of necessary scope details prevents a higher 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?

The tool has 9 parameters, no output schema, and no annotations. The description only covers one possible invocation (weather for a city) and completely ignores the other 8 parameters and their behaviors. For a tool of this complexity, the description is severely inadequate—an agent would not know how to handle parameters like 'ref', 'json', or 'path' correctly. This is far below the minimum viable completeness.

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

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

Schema description coverage is 100%, so each parameter already has a description. The tool description adds no additional semantic value beyond what the schema provides; it only mentions the 'city' parameter implicitly. According to the calibration, a baseline of 3 is appropriate when the schema carries the full burden, and the description does not compensate with extra nuance.

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

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

The description states a specific verb and resource ('Current temperature for a city via Open-Meteo'), but it misrepresents the tool's actual scope. The input schema includes 9 parameters (ref, url, feed, json, path, zone, query, etc.) that have no weather relevance, suggesting the tool is a multi-purpose hint/validation tool rather than a dedicated weather lookup. The description does not differentiate from siblings like geo-hint or iana-zones, and could lead an agent to think this is exclusively for weather.

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 any exclusions, prerequisites, or contextual cues that would help an agent decide between this and sibling tools such as geo-hint or timezone. The agent is left to infer usage from the misleading weather-only description.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only notes that the body is discarded, but says nothing about network requests, rate limits, error handling, or what happens when other parameters like city or json are supplied. This is inadequate for a tool with such a broad schema.

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

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

The description is concise (one sentence), but it is too terse to be useful. It front-loads the URL aspect but omits critical context about the other parameters, making it not a model of effective structure.

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

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

The tool has 9 parameters, no output schema, and no annotations. The description only explains a narrow URL-check behavior, leaving the agent without information about the return format for other parameter types, potential side effects, or how the tool differs from the 26 sibling tools. This is severely incomplete.

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

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

The schema provides descriptions for all nine parameters (100% coverage), so the baseline is 3. The tool description adds no extra meaning about how these parameters relate to the core function or when each should be used, but the schema itself is self-explanatory 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 states a specific action (fetch HTTP status and content type for a public URL) but fails to acknowledge the nine schema parameters, many of which (city, zone, json, path) suggest a broader multi-purpose tool. It also does not distinguish this tool from siblings like fetch-status or browser-url-ok, leaving the agent unsure which to choose.

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 its many siblings (e.g., normalize-url, validate-json, timezone). The description does not mention any conditions, 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?

With no annotations, the description carries the full burden. It discloses that 'Title discarded after the call', but this is confusing because no 'title' parameter exists. It also doesn't mention whether the operation is read-only, makes network calls, or has side effects, which is a significant gap for a check-like tool.

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

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

The description is concise (two short sentences), but it omits essential information about how to supply the title. While it is not verbose, it is under-specified to the point of being nearly useless for correct invocation.

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

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

For a tool with 9 parameters, no output schema, and no annotations, the description is grossly inadequate. It provides no indication of required parameters, expected output, error conditions, or how to formulate a valid request. The mismatch between the described purpose and the actual schema makes it impossible for an agent to use this tool correctly.

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

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

Although schema description coverage is 100%, the parameter descriptions are generic and unrelated to the tool's stated purpose. The tool description adds no mapping between its purpose and any of the 9 parameters, so it fails to explain which parameter represents the Wikipedia title. This is a critical omission.

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

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

The description states a clear purpose: check if a Wikipedia title exists. However, it does not specify which input parameter carries the title, and the schema lists unrelated parameters (ref, url, city, feed, etc.), creating confusion about how the tool is actually invoked. It also doesn't differentiate from sibling tools like 'browser-url-ok' or 'domain-shape'.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention any conditions, exclusions, or comparison to sibling tools, leaving the agent to guess the appropriate context.

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