Percent-decode length, input discarded

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 task text is discarded and that it returns connection methods, but it doesn't mention side effects, permissions, rate limits, or what happens to other input parameters. As a read-like operation, it's unclear if it has side effects. The disclosure is minimal.

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

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

The description is a single sentence with no waste. It front-loads the main action and return value. However, it could benefit from a little more structure (e.g., listing the task types explicitly), but it's appropriately concise for the information it provides.

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

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

With 9 optional parameters, no output schema, and no annotations, the description is quite incomplete. It doesn't explain how the tool is invoked, what the output format looks like, or which parameters are relevant for which tasks. An agent would need to inspect the schema to understand parameter usage, but the description doesn't provide enough context to know when or how to call this tool effectively.

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

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

Schema descriptions cover 100% of parameters, so baseline is 3. The description adds a note that task text is discarded, which hints that some parameters are only used for shape checks, but it doesn't explicitly map parameters to task types (e.g., city for weather, query for search). It adds marginal 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 clear purpose: find a public pay-per-call tool gateway for tasks like weather, search, scrape, or voice, and returns connection methods. It distinguishes from siblings by being a gateway finder, though it could be more specific about what 'gateway' means. The verb 'find' and resource 'tool gateway' are clear.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives. It doesn't mention sibling tools or conditions for selection. The only context is the task examples, but it doesn't say 'use this when you need a gateway' or exclude cases where other tools are better.

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 reveals that no browser is launched, but omits critical behaviors: what the tool actually does with the non-URL parameters (e.g., 'city', 'feed', 'json'), what the return value looks like, and whether any side effects occur. The discrepancy between the description (URL-only) and the schema (nine heterogeneous parameters) is unexplained, making the tool's behavior opaque.

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

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

The description is concise (one sentence), which is good, but it lacks structure. It front-loads the core purpose but does not introduce the broader context that the schema implies. There is no mention of the other parameter groups or the possibility that the tool performs multiple checks. The conciseness comes at the cost of completeness, so it earns a mid-range score.

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

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

The tool has 9 parameters, no output schema, and no annotations. The description is extremely thin for this complexity. It does not explain the roles of the many parameters, does not describe the output format, and does not provide usage context. An agent would be unable to correctly invoke this tool for anything beyond a simple URL check, and even then it is unclear how to supply the URL parameter. This is a severe gap.

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

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

Schema description coverage is 100%, so the baseline is 3. The schema descriptions are individually informative (e.g., 'discarded after the shape check'), but the tool description adds no extra meaning about how parameters relate to the core function. The presence of unrelated parameters (city, feed, json, zone) without explanation in the description reduces the value of the schema, as the agent cannot map parameters 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 clearly states the primary purpose: 'Check whether a URL can be opened.' It also adds a useful behavioral note ('No browser is launched.'). However, it does not differentiate from sibling tools like 'playwright-url-ok' or 'fetch-status', which likely serve similar purposes. The mismatch between the stated purpose and the extensive input schema (including 'city', 'feed', 'json', etc.) introduces ambiguity about the 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?

No guidance is provided on when to use this tool versus alternatives such as 'playwright-url-ok' or 'normalize-url'. The description gives no context about selection criteria, prerequisites, or scenarios where this tool is preferred. An agent has to infer usage from the name and description alone, which is insufficient given the large sibling set.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only states 'Expression discarded' without explaining what happens with the nine input parameters, whether the tool has side effects, what it returns, or why it exists. The description is insufficient and does not clarify the tool's behavior in any meaningful way.

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. However, it is not structured or front-loaded with critical information; it is vague and does not convey the tool's real functionality. It earns a passing score for brevity but loses points for lack of useful 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?

With nine parameters, no output schema, and no annotations, the description must provide substantial context. It offers only a one-line statement that contradicts the schema. The tool is severely under-specified; an agent cannot determine what it actually does, how to invoke it correctly, or what to expect in return.

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 a baseline of 3 might apply. However, the description's mention of 'a+b style arithmetic' does not relate to any parameter, and the description adds no extra meaning to the parameters themselves. It fails to bridge the gap between the declared purpose and the actual inputs, lowering the score to 2.

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

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

The description states a verb and resource ('Evaluate a+b style arithmetic') but the input schema contains nine parameters (ref, url, city, feed, host, json, path, zone, query) with no arithmetic expression input. The stated purpose does not map to any actual parameter, making the tool's true function ambiguous and potentially misleading to an agent.

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

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

No guidance is provided on when to use this tool versus its siblings. The description does not mention any context, alternative tools, or conditions for use. Given the large sibling list, this omission is critical for correct 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?

The only behavioral disclosure is 'Page content is not stored.' With no annotations, the description does not mention network fetch behavior, potential errors, rate limits, or side effects, leaving most behavioral aspects undisclosed.

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

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

The description is very concise and front-loaded with the core purpose. It wastes no words, though it may be too terse to cover necessary context.

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

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

Given nine parameters, no output schema, and no annotations, the description omits essential context: what the return format is, which parameters are relevant to the stated purpose, whether parameters are optional, and how errors are handled. An agent cannot reliably invoke this tool based on the current 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?

The schema lists nine parameters with descriptions like 'Git ref name,' 'City name for a public weather hint,' and 'Search text' that are unrelated to the stated purpose of returning host, scheme, and HTTP status for a URL. The descriptions do not clarify how these parameters map to the tool's actual behavior.

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 output: 'Return host, scheme, and HTTP status for a URL.' However, it does not explicitly distinguish this from sibling tools like fetch-status or normalize-url, though the verb and resource are clear enough.

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

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

No usage guidance is provided. The description does not mention when to use this tool versus alternatives, such as fetch-status or normalize-url, and gives no conditions 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?

The description only states that 'No identifiers are retained', which gives some privacy transparency but does not clarify whether the tool performs network access, file reads, or other side effects. The overall behavior remains opaque.

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

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

The description is very concise, using two short sentences with no redundant wording. It is easy to read and stays on 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?

No output schema is provided and the description does not explain what the tool returns or how the classification result is formatted. Essential information for invoking the tool correctly is missing.

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

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

The input schema covers 100% of parameters with descriptions, and individual parameter descriptions add some context (e.g., 'discarded after the shape check' implies validation). However, the relation of these parameters to the classification output is unclear.

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

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

The description 'Show how this request is classified' is vague and does not specify the exact classification criteria or the tool's core function. It does not clearly distinguish the tool from siblings like 'domain-shape' 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?

There is no guidance on when to use this tool versus alternatives. The description does not mention appropriate contexts, prerequisites, or cases where this tool should be preferred.

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 relevant behavior. It clarifies that no WHOIS/ownership lookup happens, which is useful, but it fails to mention that most parameters are 'discarded after the shape check' (as stated only in the schema), that the tool appears read-only, or what happens with invalid inputs. The description covers only the hostname case, leaving the behavior for other fields undefined.

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 to the point of being misleading. It does not front-load the tool's broad applicability (9 parameters) and wastes its brevity on a single use case, so it does not 'earn its place' despite the short length.

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 return values, error behavior, or how the shape check applies to non-hostname inputs, and it provides no context for an agent to safely call it with the right parameter. The complexity demands far more than what is offered.

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%, with each of the 9 parameters individually documented. However, the tool description adds no meaning beyond the hostname focus and does not explain how parameters relate or which one to use. It neither helps nor hurts the schema semantics, so the baseline of 3 is appropriate.

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

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

The description states a specific action (split hostname into labels) but the schema accepts 9 unrelated parameters (ref, url, city, feed, json, path, zone, query), implying a much broader 'shape check' purpose. This is misleading about the tool's actual scope and does not clearly distinguish it from sibling shape tools like github-repo-shape or figma-url-shape beyond a nod to 'without WHOIS or ownership data'.

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 choose this tool over its many siblings (e.g., normalize-url, file-path-ok, validate-json). The phrase 'without WHOIS or ownership data' hints at a lightweight check but does not name alternatives or specify conditions for selection, leaving an agent to guess which parameter should be populated.

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. It discloses the HTTP method (HEAD), the public scope, and the minimal output. It does not mention redirects, timeout behavior, or error handling, but the core behavior is transparent enough for a simple status check.

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

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

The description is a single, compact sentence with no filler or redundant wording. It is highly scannable and directly conveys the tool's action and output.

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 appears simple, but the input schema is complex with many unrelated optional parameters and no output schema. The description does not explain how the parameters relate to the HEAD request, what status format is returned, or how to pick the correct input. This leaves important context missing for an agent.

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

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

The schema has 9 optional parameters, all with descriptions that seem copied from unrelated tools. The description does not clarify which parameter is the target URL, and the 'url' parameter is described as 'HTTPS URL to normalize or cite' rather than a URL to head. This ambiguity makes it unclear how to correctly invoke the tool.

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

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

The description clearly states the verb (HEAD), the target (a public URL), and the result (status only). It is easy to distinguish from sibling tools like web-fetch, which returns page content, and status-catalog, which lists status codes.

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

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

The phrase 'return status only' implies this is for when only an HTTP status is needed, but it does not explicitly explain when to use this tool over alternatives or call out exclusions. The guidance is adequate but not detailed.

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 only states 'Path discarded,' which is a minor behavioral detail. With no annotations, it carries the full burden of disclosing side effects, return values, or error behavior, but it provides almost nothing. An agent cannot infer whether this makes network calls, is read-only, or what output to expect.

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

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

Two sentences are used, which is extremely brief, but this is under-specification rather than conciseness. Key information about purpose, usage, and behavior is omitted, so the brevity is not beneficial.

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 grossly inadequate. It fails to explain the 'shape check,' what the tool returns, or how it differs from sibling tools. An agent cannot reliably invoke this tool 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% (all parameters have descriptions), so the baseline is 3. However, the description's focus on Figma URL conflicts with the many unrelated parameters, and it does not clarify which parameter corresponds to the Figma URL or how others are handled. The description actually adds confusion rather than clarifying parameter usage.

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

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

The description states a clear verb and resource: 'Parse a Figma file URL.' However, it is limited to Figma while the schema accepts nine unrelated parameters (city, feed, host, etc.), creating confusion about the tool's actual scope. It also fails to distinguish from sibling tools like normalize-url or domain-shape that handle URLs.

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

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

No guidance is provided on when to use this tool versus alternatives such as browser-url-ok or normalize-url. The description lacks any mention of appropriate use cases, prerequisites, 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 explicitly notes 'No disk access', but it does not disclose other behavioral aspects such as return values, side effects, or failure modes. Without annotations, this is partial 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, focused sentence with no unnecessary words, meeting the highest standard of conciseness.

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

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

The tool's schema exposes nine parameters but the description gives no rationale for the extraneous ones or any usage context, leaving the agent without necessary information to correctly invoke the tool.

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

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

Although schema coverage is 100%, most parameter descriptions (ref, url, city, feed, host, json, zone, query) are irrelevant to the stated purpose of checking path safety. Only 'path' aligns with the tool's function, and the others actively confuse rather than clarify.

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 (checking path safety) and its non-disk-access behavior, making the purpose unambiguous even without sibling context.

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

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

The description provides no guidance on when to use this tool versus the many sibling tools (e.g., browser-url-ok, fetch-status, normalize-url), leaving the agent to infer applicability.

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

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

There are no annotations, so the description carries the full burden. It does not disclose side effects, data retention (though schema mentions discarding), output format, or error behavior. The schema hints at 'discarded after the check' for many parameters, but the description omits this entirely, leaving the tool's actual behavior opaque.

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

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

The description is a single short sentence, which is concise, but it is misleading and omits critical information about input usage. It does not front-load the essential details (how to specify the place) and therefore fails to be effective.

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

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

With no output schema, no annotations, and 9 parameters, the description is severely incomplete. It does not explain which parameter to use for the place, what the output looks like, or any prerequisites. The tool is far too complex for such a minimal description, and an agent cannot correctly invoke it.

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

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

Schema coverage is 100%, so baseline is 3. However, the parameter descriptions are inconsistent with the tool description—they reference shape checks, discarding, and diverse data types (refs, URLs, JSON, timezones) that do not align with a geocoding purpose. The description adds no clarification about which parameter is the place, and the parameter descriptions themselves are confusing and contradictory to the stated function.

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

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

The description states a specific function ('Latitude and longitude for a place via Open-Meteo'), but the input schema shows 9 parameters, none of which clearly identify a place except 'city', which is described as 'discarded after the call'. This creates ambiguity about how the tool is actually invoked and makes the purpose unclear. It does not distinguish from siblings like 'weather-hint' or shape-checkers.

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. There are many sibling tools (e.g., 'weather-hint', 'domain-shape'), but the description does not mention any conditions, prerequisites, or alternative selection logic.

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 'Parse owner and repo', omitting that the tool accepts nine parameters yet discards most of them, and gives no indication of side effects, return format, or error behavior.

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

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

The description is extremely concise (one sentence), which is efficient, but it is under-specified given the tool's complexity. It does not front-load critical usage context, and the brevity comes at the expense of necessary clarification.

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

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

Given nine parameters, no output schema, and no annotations, the description is wholly inadequate. It does not explain why the extra parameters exist, what the tool returns, or how it relates to the sibling tools, leaving an agent with insufficient information to call it correctly.

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

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

Schema coverage is 100%, so a baseline of 3 is expected, but the description fails to clarify that only 'url' is relevant while the other eight parameters are ignored or discarded. This creates semantic confusion about the tool's actual inputs and reduces the value the description adds beyond the schema.

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

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

The description states a specific verb ('Parse') and resource ('owner and repo from a GitHub URL'), which is clear and actionable. However, it does not distinguish itself from sibling tools like normalize-url or domain-shape that also handle URL parsing, so it lacks differentiation.

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

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

No guidance is provided on when to use this tool versus its siblings. There is no mention of alternatives or conditions for selection, leaving the agent to guess.

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

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

The description implies a read-only operation (counting), but it does not explicitly state that no side effects occur or that no external resources are modified. It also does not mention whether network access is required or if the result is cached. Given no annotations are present, the description bears this burden, and it is only partially 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?

The description is exceptionally concise, using only two short sentences. It avoids superfluous detail and gets straight to the point. This is ideal for a quick reference.

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

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

The description is incomplete for practical use. It does not explain what the tool returns (presumably a number), how to invoke it, or what the parameters are for. There is no output schema, and the description does not compensate. An agent would struggle to call this tool 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?

The description provides no information about the nine input parameters. The schema itself has generic descriptions like 'discarded after the shape check' or 'no disk access', which do not relate to the tool's purpose of counting Hacker News stories. A user cannot infer which parameters are relevant or what they control. This is a significant 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's function: counting current Hacker News front-page stories. It specifies the resource (Hacker News front page) and the action (count). The phrase 'Titles discarded' clarifies that only the count is returned. This is a specific and unambiguous purpose.

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

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

The description offers no guidance on when to use this tool over the many siblings (e.g., web-fetch, fetch-status). It does not mention that other tools might be better for retrieving content or checking status. No explicit or implicit selection criteria 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 transparency burden, but it does not disclose whether the tool is read-only, how inputs are handled, or what side effects (if any) occur. Individual parameter descriptions mention 'discarded' and 'no disk access', but these are not part of the main 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 concise — one short sentence with no filler. However, it is so terse that it fails to structure any information about the nine parameters or the intended invocation pattern.

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

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

The tool has no output schema, no required parameters, and an ambiguous purpose, making it impossible to infer correct invocation. The description does not explain what the tool returns, how to combine the optional parameters, or why most parameters are present.

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

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

Although the schema descriptions cover 100% of parameters, most of them are unrelated to the tool's stated purpose of providing IANA timezone names. Only 'zone' is clearly relevant; the others (ref, url, city, feed, host, json, path, query) have descriptions that do not explain why they belong in a timezone-name tool.

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

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

The description is a noun phrase — 'Common IANA timezone names for clock calls' — with no explicit verb like 'list' or 'return'. It is further confused by the input schema containing nine unrelated optional parameters (ref, url, city, feed, host, json, path, query) that do not align with the stated purpose.

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

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

No guidance is given about when to use this tool versus sibling tools such as timezone or utc-time. The phrase 'for clock calls' hints at a context, but there is no explicit when-to-use or alternative-selection instruction.

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 states that the tool returns 'group counts only' and fetches a public robots.txt, which implies network access and read-only behavior. However, it does not disclose error handling, timeout behavior, or how unrelated parameters (e.g., city, feed, zone) are treated. The description is too sparse for a tool with no annotation safety profile.

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

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

The description is a single sentence, front-loaded with the core action and result. There is zero fluff, and it efficiently conveys the primary function.

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

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

The tool has 9 parameters, no output schema, and no annotations, yet the description is extremely minimal. It does not explain what 'group counts' means, how the parameters relate to the primary function, or why many seemingly unrelated parameters exist (e.g., city, feed, json). The description is inadequate for an agent to correctly invoke this tool without further schema inspection, and even then the purpose of the extra parameters 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 description coverage is 100%, so each parameter is already documented. The description adds no parameter semantics beyond what the schema provides; it does not clarify which parameter is the target for robots.txt (likely 'url') nor explain the role of the other eight parameters. Baseline 3 is appropriate because the schema covers the parameters, but the description offers no extra 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 a specific verb ('fetch') and resource ('public robots.txt') with a defined result ('group counts only'). It is clear but does not explicitly differentiate from sibling tools like web-fetch or fetch-status that also fetch URLs. A 4 reflects clarity without sibling distinction.

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 exclusions, prerequisites, or scenarios where another tool (e.g., web-fetch) would be more appropriate. The only implied usage is 'if you need robots.txt group counts', but this is not explicit.

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

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

No annotations are present, so the description bears the full burden. It only states 'Key discarded,' which hints at no side effects but does not explain return behavior, error conditions, or any side effects beyond input disposal. 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 short sentence, which is concise but under-specified. It is not front-loaded with key information because there is almost no information. The structure is acceptable but offers no actionable detail.

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

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

For a tool with 9 optional parameters and no output schema, the description is far too thin. It does not explain how to supply the Jira key, what the expected input format is, or what the result looks like. The agent would be forced to guess which parameter to use and what 'shape' means.

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 already cover all 9 parameters at 100%, so the baseline is 3. The description itself adds no parameter-specific context; it does not even indicate which parameter holds the Jira key. Thus it does not enhance the schema's clarity.

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 a Jira issue key shape.' This distinguishes it from sibling shape-checkers like domain-shape or github-repo-shape, but it does not specify what the shape is or what output is expected, leaving the exact purpose slightly 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?

No guidance is provided on when to use this tool versus alternatives. It does not mention context, prerequisites, or exclusions. The agent must infer that this is specifically for Jira keys based on 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 carries the full burden of behavioral disclosure. It only states that the body is discarded, implying a non-content return. It does not disclose whether the tool makes network requests, follows redirects, has timeout behavior, or requires any permissions. It also does not mention the exact return format (only 'HTTP status' is implied). This is minimal and leaves critical behavior undisclosed for a network 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 short sentence, which is concise but severely under-specified for a tool with 9 parameters and many siblings. The main verb is present, but the lack of detail makes it ineffective. It is not appropriately sized for the complexity; brevity here sacrifices necessary 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?

For a tool with 9 parameters, no output schema, and no annotations, the description is grossly incomplete. It does not explain the return value beyond 'HTTP status', does not mention any error cases, does not clarify which parameter is the primary input, and provides no examples or edge-case handling. An agent would struggle to call this tool correctly.

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

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

Schema coverage is 100% and the schema provides descriptions for all 9 parameters, so the baseline is 3. However, the description adds no parameter-specific meaning and, more critically, it conflicts with the parameter set: parameters like 'city', 'feed', 'zone', and 'query' have no apparent relation to the stated HTTP-status purpose. This inconsistency makes it harder, not easier, for an agent to determine which parameters are relevant, dropping the score below baseline.

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

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

The description states a specific verb and resource ('HTTP status for a public library docs URL') but is ambiguous: 'public library docs URL' is not a standard category, and the tool name 'lib-docs-hint' suggests it might be for hinting rather than a direct fetch. It does not differentiate from siblings like fetch-status or browser-url-ok, which also check HTTP status. The broad parameter set (city, feed, zone, query) further obscures the actual purpose.

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

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

No guidance is provided on when to use this tool vs alternatives. Siblings like fetch-status, normalize-url, and browser-url-ok perform similar checks, but the description does not mention any selection criteria, exclusions, or alternative tools. An agent has no way to know 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?

No annotations are provided, so the description carries full behavioral burden. It only states 'Values discarded' but gives no information about error handling, output format, or behavior on invalid JSON. The schema descriptions add confusion by saying values are 'discarded after the check' without connecting to counting keys.

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, which is concise, but it is under-specified and not front-loaded with the most critical information (which parameter to use). It sacrifices clarity 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 inadequate. It does not explain the return value, error behavior, or which parameter is essential. An agent cannot reliably use this tool.

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

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

While schema coverage is 100%, the description adds no linkage between parameters and the tool's purpose. The 'json' parameter description ('JSON text to validate; discarded after the check') suggests validation, not key counting, and many other parameters are irrelevant to counting keys. The description fails to clarify which parameter is the input.

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

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

The description states a specific operation (count keys) and resource (JSON object), but it does not clarify which input parameter carries the JSON object. The schema lists 9 unrelated string parameters, so an agent cannot confidently determine how to invoke the tool.

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

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

No guidance is provided on when to use this tool versus siblings like validate-json or domain-shape. The description does not mention any conditions, prerequisites, 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?

No annotations are provided, so the description carries the burden of disclosing side effects, persistence, or read-only behavior. It only describes output transformation and does not mention error behavior, failures, or whether inputs besides 'url' have any effect.

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 scannable, stating the core behavior in two sentences. It could be improved by listing the relevant parameter or explicitly saying that all other parameters are ignored.

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 and no output schema or annotations. The description only explains URL handling and completely omits behavior for eight parameters, making it severely incomplete for such a complex input surface.

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

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

Schema descriptions cover 100% of parameters, but the tool description does not explain why unrelated parameters like ref, city, feed, json, path, zone, and query exist. The description's use of 'query' as a URL component conflicts with the schema's 'query' parameter described as search text, creating ambiguity.

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

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

States a clear operation: return origin, host, and path for a URL and drop query/fragment. The name reinforces this. It loses a point because the input schema includes many unrelated parameters that the description does not reconcile with the stated purpose.

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

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

No guidance on when to use this tool versus sibling URL-related tools such as browser-url-ok, fetch-status, or web-fetch. It also does not explain which of the nine parameters are actually needed or ignored.

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

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

The description and parameter hints indicate that inputs are 'discarded' and that no disk access occurs, which partially signals no side effects. However, it does not disclose what happens when multiple parameters are provided, whether decoding is applied to one field or all, what errors may occur, or what the output looks like.

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 omits crucial operational details. Being concise is not helpful when key information is missing. The structure is a single vague phrase rather than a clear, well-formed tool specification.

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

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

With 9 optional parameters, no output schema, and no annotations, the description is grossly incomplete. It does not specify which parameter to use, how to invoke the tool correctly, what the return value represents, or any edge cases. This is far from sufficient for an agent to use the tool reliably.

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

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

Although the schema covers all 9 parameters with descriptions, those descriptions do not tie each parameter to the percent-decode-length operation. For example, 'url' is described as 'HTTPS URL to normalize or cite', which is unrelated to percent-decoding or length calculation. The parameter roles are effectively unexplained for this tool's actual 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 'Percent-decode length, input discarded' is too terse and ambiguous. It does not clearly state which parameter is the input to be percent-decoded, nor what the tool returns (e.g., an integer length). It reads more like a fragment than a clear purpose statement, and the phrase 'input discarded' is confusing.

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 sibling tools such as normalize-url, search-query-len, or validate-json. The description does not mention any scenario, prerequisite, or alternative, so an agent has no basis for selecting this tool appropriately.

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 states 'No browser is launched,' which is a useful non-destructive hint, but it doesn't mention whether network requests are made, side effects, rate limits, or what happens on failure. The schema hints at input discarding, but the description itself is silent on these critical details.

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

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

The description is a single, efficient sentence with no wasted words. It is front-loaded with the core purpose and includes a key behavioral caveat. Perfectly concise, though it sacrifices 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?

This is a 9-parameter tool with no annotations and no output schema. The description is far too brief to explain what happens with the other parameters, what the return value looks like, or when to use it. It is grossly inadequate for an agent to correctly invoke this tool.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds no value in clarifying which of the 9 parameters is central. It accepts a url, city, feed, json, path, zone, query, etc., but the description only mentions URL checking, leaving confusion about the purpose of the other parameters. The description fails to tie parameters to the tool's purpose.

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

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

The description states a specific verb ('check') and resource ('URL'), and clarifies that no browser is launched, which distinguishes it from browser-url-ok. However, it doesn't specify the exact method (HTTP status, DNS, reachability) or differentiate from other URL-checking siblings like fetch-status or web-fetch, leaving ambiguity about what 'can be opened' means.

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. There is no mention of conditions, exclusions, or references to sibling tools. An agent must infer from the name and description alone, which is insufficient.

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 states 'Query discarded,' which is a minor behavioral detail. It does not disclose whether the tool makes external calls, whether it is read-only, or how other parameters are handled. The phrase 'Query discarded' is ambiguous—does it mean only the query is discarded, or all inputs are discarded after counting?

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 front-load the main function, but the lack of context makes it feel more like a stub than a helpful description.

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

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

For a tool with 9 parameters, no required fields, and no output schema, the description is grossly incomplete. It does not explain how the tool processes the various parameters, what it returns, or how it interacts with the many 'discarded' fields. An agent cannot reliably use this tool based on the given 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?

Although schema coverage is 100%, the description does not clarify which parameter is the 'search query.' It adds no value beyond the schema's per-parameter descriptions, and it does not help map the parameters to the tool's purpose. The description could have specified 'the query parameter' but does not.

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

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

The description says 'Count characters in a search query,' which is a specific verb and resource, but it is ambiguous which of the 9 input parameters is the search query. It fails to identify that the 'query' parameter is the target, and it does not differentiate this tool from siblings like 'percent-decode-len' or 'memory-key-count'.

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. There is no mention of conditions, prerequisites, or exclusions. An agent has no idea if this should be used for validating query length or something else.

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

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

The description does not disclose side effects, output format, or whether inputs affect behavior. The schema hints that parameters are 'discarded' or checked, but the description itself offers no transparency about the tool's actual behavior.

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

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

The description is brief, but brevity here comes at the expense of necessary detail. It lacks a verb and any mention of output or behavior, making it too minimal to be genuinely useful.

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

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

With no output schema and no explanation of side effects or returned data, the description is incomplete. An agent cannot determine what a successful call yields or how to interpret the catalog content.

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

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

Although the schema covers 100% of parameters, the descriptions are nonsensical relative to the stated purpose (e.g., 'discarded after the shape check', 'no disk access'). They do not clarify how any parameter relates to returning HTTP status codes, and all nine are optional, further obscuring their role.

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

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

Description is a noun phrase ('Short catalog of common HTTP status codes') with no verb specifying the action or result. It does not state what the tool does with inputs or what it returns, making its purpose 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?

No guidance is given about when to use this tool versus sibling tools. Given the many similar tools (e.g., fetch-status, web-fetch), the absence of any selection criteria leaves the agent to guess.

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

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

With no annotations, the description carries the full transparency burden. It discloses only that a 'prompt' is discarded, but omits side effects, the output format, and whether any of the URL/host/path parameters cause network or filesystem 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 only two sentences, but 'Prompt discarded' is ambiguous and arguably wastes the second sentence on an unexplained behavior. The structure is acceptable but not exemplary.

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

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

There is no output schema and no annotations, so the description must stand alone. It does not explain the template's contents, the return type, parameter relevance, or any constraints; an agent has almost no context to invoke 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 coverage is 100%, giving a baseline of 3, but the individual parameter descriptions are inconsistent with the tool's stated purpose and look like copied snippets from unrelated tools. The tool description adds no unifying explanation of how ref, city, feed, json, path, etc. relate to a thinking template.

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

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

The description names an action and object ('Return a three-step thinking template') but never defines what a 'thinking template' is. The sentence 'Prompt discarded' further muddles the purpose, especially since no prompt parameter exists and the schema contains nine unrelated-looking parameters.

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

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

No guidance is given for when to use this tool or how it differs from the many sibling utilities (e.g., normalize-url, validate-json, fetch-status). There is no alternative mentioned or condition for selection.

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

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

With no annotations, the description carries the burden of disclosing behavior, but it only states the primary function. It does not mention whether the tool is read-only, has side effects, or ignores the many unrelated input 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 a single, concise sentence that is immediately clear and front-loaded. It does not waste words or include redundant detail.

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

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

Given the tool has 9 parameters and no output schema or annotations, the description is not contextually complete. It fails to explain the purpose or handling of the majority of input fields, leaving significant ambiguity for an agent.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no meaning beyond the schema, and while it does align with the 'zone' parameter, it leaves the other eight parameters unexplained in the tool description.

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

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

The description clearly states a specific action and resource: returning current time for a named IANA timezone. However, the input schema contains eight other seemingly unrelated parameters, which creates some ambiguity 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?

No usage guidance is provided. The description does not explain when to use this tool versus sibling tools like iana-zones or utc-time, nor does it provide any context about alternative tools or appropriate invocation scenarios.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It implies a simple read-only operation but does not explicitly state side effects, permissions, or the fact that the 9 input parameters appear to be ignored or irrelevant.

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, focused phrase with zero redundant words and no unnecessary detail. It is front-loaded and immediately conveys the core purpose.

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

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

The tool is simple, but the presence of 9 seemingly irrelevant parameters creates significant context gaps. The description does not address output format, parameter usage, or whether inputs are silently discarded, leaving an agent uncertain about correct invocation.

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

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

The input schema contains 9 parameters with descriptions unrelated to the tool's purpose (e.g., 'Git ref name,' 'HTTPS URL,' 'City name'), which is highly confusing. The description does not explain why these parameters exist or whether they are accepted but ignored, adding 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 clearly identifies the tool's output as the current UTC timestamp, which distinguishes it from sibling tools like timezone and iana-zones. However, it lacks an explicit verb such as 'get' or 'return,' though the intent is still unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives like timezone or iana-zones. There is no mention of scenarios, prerequisites, or conditions that would make this tool the preferred choice.

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

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

There are no annotations, so the description must carry the full burden of behavioral disclosure. It does disclose that 'the body is discarded,' which is a useful side-effect note. However, it does not explain what the tool returns (e.g., boolean, error message), nor does it clarify which parameter constitutes 'the body.' This ambiguity undermines 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 exceptionally short—two sentences with no filler. It front-loads the primary action and includes a behavioral note. However, its brevity sacrifices critical information, so it earns a 4 for conciseness but not a 5 because it omits necessary context.

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

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

With 9 optional parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain what happens to the other eight parameters (e.g., ref, url, city) or whether they are ignored. The tool's actual behavior beyond JSON validation is unclear, making it difficult for an agent to call correctly.

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

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

While the input schema provides 100% coverage with descriptions for each parameter, the tool description adds no value by rephrasing them. It uses the vague term 'body' without linking it to the 'json' parameter, which is the only one relevant to JSON validation. The schema itself is informative, but the description fails to leverage or clarify the relationship, leaving the agent uncertain about which fields 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 clearly states the tool's core function: checking whether a body is valid JSON. It uses a specific verb ('check') and resource ('body is valid JSON'), making the purpose understandable. However, it does not explicitly differentiate from sibling validators like 'domain-shape' or 'fetch-status', but the name 'validate-json' is self-explanatory enough to stand out.

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 prerequisites, typical use cases, or situations where another validator would be more appropriate. With 28 sibling tools, the lack of routing or context leaves the agent to guess.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not mention that the tool is read-only, that it makes network calls (implied by 'Open-Meteo'), or that many of the schema parameters are irrelevant to this tool's function. The description does not disclose that only the 'city' parameter is used and others are discarded, which 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 brief (one sentence), which could be considered concise, but it lacks critical context. It under-specifies the tool's behavior and parameter usage, so it is not effectively structured for an agent. The brevity is not a virtue here; it results in an incomplete definition.

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 with none required, and no output schema, the description should clarify that only 'city' is needed for the temperature function and that other parameters are irrelevant. It does not do this. An agent would be uncertain about which parameters to provide and what the return value looks like. The description is incomplete for a tool with such a broad input schema.

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

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

The schema provides descriptions for all 9 parameters (100% coverage), so the schema already explains each parameter's purpose. The tool description adds no parameter-level information beyond the schema, and it does not clarify which parameters are actually relevant for the temperature lookup. Since the schema is comprehensive, the baseline is 3, but the description fails to add value or highlight the essential parameter.

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

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

The description clearly states the tool returns the current temperature for a city via Open-Meteo, using a specific verb and resource. It is unambiguous about its primary function, but it does not differentiate from sibling tools like 'geo-hint' or other hint tools, which may offer similar geographic or weather-related capabilities.

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

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

No guidance is provided on when to use this tool versus alternatives. The description only states what the tool does, not when to invoke it, nor does it mention any exclusions or conditions. An agent would not know if this is the right tool for a given weather query or if a sibling like 'geo-hint' is more appropriate.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose that the body is discarded and that it returns status and content type, which is useful. However, it does not mention any other behavioral traits such as handling of redirects, error responses, or rate limits, so it is minimal but not contradictory.

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

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

The description is a single sentence that front-loads the core purpose and key behavior (body discarded). There is no redundancy or fluff, making it highly efficient for an agent to parse.

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

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

Given the tool has 9 optional parameters covering diverse inputs (ref, city, feed, json, path, zone, query) and no output schema, the description only explains one use case (a public URL). It fails to explain how the other parameters are used or why they exist, leaving the tool's actual scope ambiguous and incomplete for an agent to call correctly.

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

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

The schema covers all 9 parameters with individual descriptions, so the baseline is 3. The tool description adds no extra meaning about the parameters; it only mentions 'public URL' which aligns with the url parameter. There is no additional context to help disambiguate the many 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 (fetch) and the result (HTTP status and content type) for a public URL, and notes that the body is discarded. It is specific about the resource and output, but it does not differentiate from siblings like fetch-status or browser-url-ok, which might also provide status information.

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

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

The description provides no guidance on when to use this tool versus the many siblings (e.g., fetch-status, normalize-url, browser-url-ok). It does not state any conditions, alternatives, or exclusions, leaving the agent to infer the appropriate context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that the title is 'discarded after the call,' indicating statelessness, but does not disclose what happens on success or failure, whether it performs network access, what the return format is, or any side effects. For a check tool, this is minimal and insufficient.

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

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

The description is extremely concise with two short sentences, but conciseness here veers into under-specification. It states the purpose but omits essential operational details. The structure is minimal with no front-loading of critical usage constraints or parameter relationships, making it less effective than a slightly longer, more structured description.

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

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

This tool has 9 parameters, none required, no output schema, and no annotations. The description fails to explain how the parameters relate to the stated purpose of checking a Wikipedia title, nor does it describe expected return values or error conditions. Given the complexity implied by the parameter count, the description is woefully incomplete and leaves the agent without enough context to call the tool correctly.

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

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

Schema description coverage is 100%, so each parameter already has a description, earning a baseline of 3. However, the tool description adds no parameter meaning beyond the schema, and it does not clarify which parameter represents the 'title' to check. The parameters listed (ref, url, city, feed, host, json, path, zone, query) are generic and do not intuitively map to a Wikipedia title, leaving ambiguity about how to actually invoke the tool.

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

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

The description clearly states the tool's core action: checking whether a Wikipedia title exists. It uses a specific verb ('check') and a specific resource ('Wikipedia title'), making the primary purpose unambiguous. However, it does not differentiate itself from sibling tools like 'browser-url-ok' or 'fetch-status' that might also verify existence, and the description is too terse to distinguish scenarios.

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 prerequisites, when not to use it, or how it relates to other existence-checking tools in the sibling list. The description provides no context about the intended use case, leaving the agent to infer when this tool is appropriate.

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