Language lv

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

With no annotations, the description must carry behavioral disclosure. It mentions 'Task text is discarded' and 'Returns connection methods', but does not disclose whether network calls, permissions, rate limits, or side effects are involved. The tool's connection to 'pay-per-call' behavior is not clarified.

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-loads the main purpose, but the final 'Task text is discarded' is cryptic and could confuse. Every sentence should earn its place; this one introduces an unexplained concept.

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 and no output or annotations, the description is insufficient. It does not explain what 'connection methods' look like, which fields should be supplied, or how the task is inferred. An agent would struggle to invoke this tool correctly.

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

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

Schema descriptions cover 100% of parameters, so the baseline is 3. The description adds no meaningful guidance on how the 9 optional parameters relate to the task of finding a gateway; 'Task text discarded' is not mapped to any schema field, providing no extra semantics.

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

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

The description states a specific verb ('Find') and resource ('public pay-per-call tool gateway'), with examples of tasks. However, it is vague about how the task is specified — the schema has 9 parameters but no 'task' parameter — and the phrase 'Task text is discarded' is confusing, making the exact purpose unclear.

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

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

No explicit guidance on when to use this tool vs. the 28 sibling tools. It does not state exclusions or conditions, and the lack of a 'task' parameter leaves agents uncertain about which input to provide.

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 'No browser is launched,' which clarifies a non-action but is minimal. No annotations are provided, so the description carries the full burden. It does not explain what 'can be opened' means (syntactic validity vs. reachability), what happens when multiple parameters are supplied, or what the return value looks like. This is insufficient for a tool with 9 diverse inputs.

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

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

The description is extremely short (one sentence), which is concise in length but under-specified in content. It front-loads the URL check but omits essential details about the tool's broad parameter handling. Conciseness is not valuable when it sacrifices necessary information—this is under-specification rather 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?

With 9 parameters, no output schema, and no annotations, the description is grossly incomplete. It only addresses URL checking while ignoring the other 8 parameter types. There is no explanation of how the tool processes these varied inputs, whether they are mutually exclusive, or what the expected output is. An agent cannot confidently call this tool for anything beyond a basic URL check.

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

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

Schema description coverage is 100%, so the schema already documents each parameter (e.g., 'Git ref name; discarded after the shape check'). The tool description adds no parameter-specific meaning beyond what the schema provides. Baseline is 3 because the schema does the heavy lifting; the description contributes nothing extra.

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 'Check whether a URL can be opened,' which is a specific verb and resource. However, the input schema accepts 9 diverse parameters (url, json, path, zone, etc.) that go well beyond a URL check. The description is misleading about the tool's actual scope, as many parameters are unrelated to URL validation. This is a clear mismatch between the described purpose and the actual capability.

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 vs. siblings like domain-shape, file-path-ok, validate-json, or normalize-url. The description does not mention any conditions, exclusions, or alternatives. An agent would have no idea whether to pick this tool over the specialized siblings for a given input type.

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

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

No annotations exist, so the description must describe behavior on its own. It only says the expression is discarded, while saying nothing about return values, side effects, permissions, or whether any of the 9 parameters are actually consumed.

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

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

The description is very short, begins with the main purpose, and contains no filler or redundancy. The second sentence is ambiguous but not bloated; the conciseness itself is good.

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 annotations, and no output schema, this two-sentence description is far too thin. It does not explain why the parameters exist, how to supply the arithmetic expression, or what a successful call returns.

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

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

Schema description coverage is high and the schema parameters are individually described, which would warrant a baseline of 3. But none of the schema parameters clearly carries the arithmetic expression central to the tool, and the description does not map 'expression' to any input field.

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

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

The description names a concrete operation, 'Evaluate a+b-style arithmetic', so it is not just a tautology. However, it never connects that arithmetic expression to any of the 9 schema parameters, and the phrase 'Expression discarded' adds ambiguity about whether an expression is accepted at all.

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 instead of the many sibling validators and checkers. It gives no conditions, exclusions, or alternative tool references.

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 does disclose that page content is not stored, which is a useful behavioral trait. However, it does not state whether a network request is made, whether the operation is read-only, or any error behavior. It implies a safe read but lacks explicit disclosure of side-effects or limitations.

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, no fluff. The main purpose is front-loaded and the behavioral disclosure follows immediately. Every word serves a purpose, and the text is extremely efficient.

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

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

The description states the return values (host, scheme, HTTP status) and the no-storage policy, which is useful. However, it omits when to use this tool, how it interacts with the other 8 parameters, and what happens on invalid URLs or non-200 responses. Given no output schema, the description should be more complete.

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

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

Schema description coverage is 100%, so the schema documents all 9 parameters. The description adds no additional meaning beyond the schema; it only mentions 'URL' generically without explaining that only the 'url' parameter is actually used while others are discarded. It doesn't enrich parameter understanding.

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

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

Description clearly states the operation: 'Return host, scheme, and HTTP status for a URL' – a specific verb and resource. It also adds a distinguishing detail ('Page content is not stored') that separates it from content-fetching tools like web-fetch. However, it doesn't explicitly name sibling tools or contrast with similar URL-check tools like fetch-status or normalize-url, 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 guidance on when to use this tool versus alternatives. It doesn't mention conditions for choosing citation over fetch-status, normalize-url, or web-fetch, nor does it explain any exclusions or prerequisites. The agent is left to infer usage from the description alone.

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

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

The description discloses that 'No identifiers are retained,' which is a useful behavioral trait. However, with no annotations provided, the description must carry the full burden of behavior disclosure. It does not state whether the operation is read-only, whether it makes external calls, or what side effects (if any) exist. The disclosure of retention is a positive but insufficient addition given the tool's complexity.

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

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

The description is extremely concise (one sentence), but conciseness should reward efficient communication of necessary information. This description under-specifies the tool's purpose and behavior, so it is not appropriate conciseness but rather under-specification. The front-loaded information is minimal and not informative.

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

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

With 9 optional parameters, no output schema, no annotations, and a large sibling set, the description is completely inadequate. It does not explain what classification result is returned, which parameters are relevant, or how to interpret the output. An agent would not be able to call this tool correctly or decide when to use it based on this definition.

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

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

Schema description coverage is 100%, so each of the 9 parameters has a descriptive entry in the schema. The tool description itself adds no additional parameter semantics — it does not explain how parameters relate to the classification or what is required. Baseline 3 is appropriate because the schema already documents each parameter thoroughly.

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

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

The description says 'Show how this request is classified,' which is vague and does not specify the verb-resource relationship clearly. It does not state what kind of classification is performed, what inputs are used, or how it differs from sibling tools like 'domain-shape' or 'file-path-ok' that likely perform similar shape/format checks. The name 'compatibility' hints at a purpose, but the description alone doesn't make it concrete.

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 mentions no contexts, no exclusions, and no mention of sibling tools. An agent gets no help deciding between 'compatibility' and the many similar shape-checking tools in the sibling list.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the tool splits a hostname and omits WHOIS/ownership data—it says nothing about side effects, return values, rate limits, or operational constraints. Given the schema hints that many inputs are 'discarded after the call,' the description fails to explain this behavior, leaving the agent with minimal insight.

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 structurally efficient. However, it is so brief that it omits critical information about the tool's multi-parameter nature and alternatives. It is concise but at the expense of completeness—concision without substance 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 parameters, no annotations, and no output schema, the description is grossly inadequate. It covers only one facet (hostname splitting) and leaves the purpose of all other parameters unexplained. There is no mention of return format, error behavior, or use cases. The description fails to provide the essential context an agent needs 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 each parameter has its own description, so the schema already documents parameter meaning. However, the tool description only addresses 'hostname' and gives no unifying explanation for the other eight parameters. An agent would not infer that the tool can handle URLs, cities, JSON, etc., nor how these relate to 'domain-shape.' The description adds little semantic value beyond the schema and even hinders understanding of the parameter set.

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 a hostname into labels') and notes a limitation (no WHOIS/ownership data), which helps distinguish it from data-enrichment tools. However, it misrepresents the tool's scope: the input schema accepts nine different parameter types (ref, url, city, feed, json, path, zone, query) each with its own purpose, yet the description only mentions hostname. This creates confusion about what the tool actually does and 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 its many siblings (normalize-url, playwright-url-ok, fetch-status, etc.). The description does not state prerequisites, exclusions, or alternative tools. The single sentence implies hostname-only usage, which directly conflicts with the schema's broader input set, providing misleading usage clues.

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 reveals the HEAD behavior and the 'status only' outcome, but is silent on what happens when other parameters are supplied (e.g., 'discarded after check' in the schema is not reflected in the description). The discrepancy between the described behavior and the parameter set seriously 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 a single sentence with no fluff, which is concise in word count, but it is severely under-specified for a tool with 9 parameters and 27 siblings. It does not 'earn its place' because it misrepresents the tool's true scope, making the brevity a liability rather than an asset.

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

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

Given the complexity (9 parameters, no output schema, no annotations), the description is grossly incomplete. It does not explain how the diverse parameters affect behavior, what the return value actually includes (only 'status' for the URL case), or how the multiple 'shape check' scenarios are handled. The description is inadequate for an agent to correctly invoke the tool for any non-URL 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%, so each of the 9 parameters already has a description in the input schema. The tool description adds no additional semantic meaning beyond the schema. Since the schema is complete, the baseline 3 is appropriate; the description neither enhances nor contradicts the parameter documentation, though it fails to explain how parameters relate to each other.

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 ('HEAD a public URL and return status only'), but it is misleading because the input schema includes 9 unrelated parameters (city, zone, query, json, path, etc.) that suggest a multi-purpose shape-check tool, not just URL status. It fails to distinguish from sibling tools like browser-url-ok or domain-shape, and the narrow description contradicts the breadth of 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?

There is no guidance on when to use this tool versus alternatives. The description does not mention any exclusions, prerequisites, or conditions for selection among the 27 siblings. A tool with this many parameters needs explicit routing logic, which is completely absent.

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 transparency burden entirely. The single disclosed trait is 'Path discarded,' which says nothing about what the tool returns, what a valid Figma file URL looks like, how invalid inputs are handled, or whether any HTTP/network interaction occurs. The behavioral profile is essentially one isolated fact.

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 very short sentences with a clear front-loaded verb+resource and zero fluff. However, the second sentence ('Path discarded.') is cryptic and does too little work for the amount of ambiguity it leaves, so the trim structure is terse but not rendering to be genuinely informative.

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

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

For a tool that carries 9 optional parameters, no annotations, and no output schema, this description is far too sparse. It doesn't explain what the return value is, what shape criteria are checked, why parameters in the schema span unrelated domains (city, feed, json, zone, query), or how the agent should translate a user query into a correct call. These holes make it unsafe for an agent to invoke with confidence.

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

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

With 100% schema description coverage, the baseline of 3 applies; the description adds no parameter-specific guidance beyond that baseline. In fact, the description never states which of the 9 optional parameters (url vs. path) is meant to receive the Figma file URL, so an agent still has to guess the intended entry point. Wait, the 100% coverage keeps it at a baseline 3.

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

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

States a specific verb + resource ('Parse a Figma file URL') and adds one scoping behavior ('Path discarded'). This is clear enough on its own, but it does not call out how it relates to the many sibling validators (normalize-url, browser-url-ok, github-repo-shape), so the 'parse' outcome still has to be inferred rather than stated.

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 whatsoever: no when-to-use conditions, no exclusions, no alternatives named. With near-identical siblings like normalize-url, browser-url-ok, and the other *-shape tools, an agent has nothing to route on and will likely pick this tool more by name than by intent.

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 disclosure burden. It states only 'no disk access', leaving the agent without information about output format, side effects, edge cases, or the meaning of 'safe'. Given the tool has many parameters and no output schema, this is a significant behavioral gap.

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

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

The description is extremely concise: two sentences with no wasted words, and the key behavioral fact ('no disk access') is front-loaded. It can be understood at a single glance, even though the brevity may under-serve other dimensions.

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

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

The tool has no output schema, no annotations, and a nine-parameter input schema, yet the description says nothing about return values, accepted parameter combinations, or which parameter actually represents the path. The agent will likely be confused about how to properly 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?

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning and does not even indicate which of the nine parameters is the relevant 'path' parameter, despite the tool name and description focusing on it. The schema descriptions themselves are the only source of parameter semantics.

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

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

The description clearly states a specific verb ('check') and resource ('a path'), and adds a key safety property ('no disk access'). It distinguishes the tool as a path-safety check, but it does not differentiate from similar validation tools (e.g., browser-url-ok, normalize-url), and the schema's nine unrelated parameters create 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?

The description gives no guidance on when to use the tool versus alternatives, nor does it mention any exclusions or prerequisites. The only hint is 'no disk access', which is insufficient for an agent to decide whether to invoke this tool instead of a sibling tool.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It does not mention network calls to Open-Meteo, parameter discard semantics (even though the schema notes some are discarded), or any side effects. The agent is left with no understanding of the tool's runtime 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 sentence, but it is under-specified rather than concise. It omits essential information about input selection and behavior, so brevity does not serve the agent. Appropriate conciseness would include the key parameter or usage 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?

With nine parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain return format, required input, or parameter relationships. An agent has no chance of invoking this tool correctly based on the description alone.

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

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

Schema description coverage is 100%, so the baseline is 3, but the tool description adds no meaning about how the nine parameters map to retrieving a place. The schema descriptions themselves are contradictory (e.g., city is described as 'for a public weather hint'), and the description does not clarify which parameter yields the coordinates. Thus, the description fails to bridge the semantic 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 states the tool returns latitude and longitude for a place via Open-Meteo, which is a concrete outcome. However, it does not specify which input parameter identifies the 'place' (e.g., city, host, path, query), leaving the invocation unclear. It is not a tautology, but it lacks the specificity needed to distinguish from siblings like weather-hint or timezone.

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

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

No guidance is given on when to use this tool versus alternatives. There is no mention of conditions, exclusions, or sibling tools, so an agent cannot decide between geo-hint and other hint tools based on the 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?

No annotations are present, so the description carries the full burden. It only states the core action without disclosing behavior on invalid URLs, whether network access is involved, or how the other 8 parameters are treated. The presence of unrelated parameters (city, feed, host, etc.) without explanation makes 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, focused sentence that front-loads the essential action. It is appropriately terse for a simple utility, with no filler or redundancy.

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

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

The tool has no output schema and relies solely on the description to convey what the agent will receive. It does not specify the return format, error behavior, or which parameters actually affect the result. The large set of optional parameters with no explanation makes the tool incomplete for an agent to invoke correctly 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?

Schema coverage is 100%, so the baseline is 3. However, the description fails to indicate that only 'url' is relevant; the schema describes each parameter but gives no hint that most are ignored or vestigial. This creates confusion about parameter usage, and the description does not compensate for the mismatch between the tool's stated purpose and the broad parameter set.

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 'Parse owner and repo from a GitHub URL' states a specific verb (parsing), a concrete resource (GitHub URL), and the extracted data (owner and repo). It clearly distinguishes this from sibling tools like normalize-url or domain-shape, which handle generic URLs or domains.

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 conditions, prerequisites, or exclusions. An agent must infer usage solely from the tool name and description, which is insufficient for selecting among several URL-related tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that titles are discarded, implying only a count is returned, but it does not disclose that the nine input parameters are apparently irrelevant or ignored. This is a major gap: an agent could waste effort passing parameters that have no effect, and no side effects, permissions, or rate limits are mentioned.

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

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

The description is very short, consisting of two sentences. It is front-loaded with the primary purpose ('Count current Hacker News front-page stories') and the second sentence adds a note about titles. There is no fluff or repetition, but the second sentence is ambiguous and could be expanded to clarify the 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?

Given the tool has no output schema and nine optional parameters, the description is far too sparse. It does not specify the return format (e.g., just a numeric count), whether parameters are ignored, or any limitations. An agent cannot reliably know how to invoke this tool correctly, even though it appears to be a simple counter.

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 tool description adds no meaning to the parameters. The schema lists generic parameters like 'city', 'path', and 'query' with descriptions that are unrelated to counting HN front-page stories. The description does not explain how these parameters are used (if at all), and does not compensate for the schema's lack of connection to the tool's purpose. The agent is left confused about whether to pass any arguments.

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

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

States a specific verb ('Count') and resource ('current Hacker News front-page stories'), making the core action clear. It is distinct from sibling tools that fetch pages or validate URLs, but it does not explicitly differentiate itself from any particular sibling or warn about similarity.

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. The description does not mention any context, prerequisites, or exclusions. It leaves the agent to infer that it should be used when a count of HN front-page stories is needed, but offers no hints about when not to use it or what tools might be 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, the description carries the full burden of behavioral disclosure, but it says nothing about what the tool does—no mention of side effects, return values, or how inputs are handled. The schema notes that most parameters are discarded, but that's structural data, not behavior. The description is purely declarative and fails to disclose any 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 extremely short (one sentence), which is concise, but it doesn't earn its place because it lacks substance. It doesn't front-load key information or structure the content usefully. A slightly longer description with clear action and scope would be more 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?

For a tool with 9 parameters, many of which appear unrelated (ref, url, city, feed, etc.), the lack of clarity about which parameters are relevant and what the tool does is a severe gap. There is no output schema or annotations to compensate. The description is entirely inadequate for an agent to understand the tool's functionality.

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 parameters have descriptions in the schema. The tool description adds no meaning beyond those—it doesn't reference or clarify any parameter, including 'zone', which seems most relevant. Baseline 3 applies because the schema already documents parameters adequately.

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

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

The description names a resource ('IANA timezone names') and a context ('for clock calls'), but lacks a verb or explicit action. It's unclear whether the tool returns a list, validates a zone, or does something else. This is more than a tautology but still vague enough to require inference.

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 over siblings like 'timezone' or 'utc-time'. There are no conditions, alternatives, or exclusions mentioned. The only hint is 'for clock calls', which doesn't clearly differentiate it from related tools.

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

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

With no annotations, the description needs to carry the behavioral load. It does say 'public' and 'Fetch', revealing a read-only network access that returns only a count, but it stays silent on failures, rate limits, robots.txt size limits, or how it handles redirects. This is a middle-ground disclosure that adds some clarity but not enough for a public fetch.

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

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

The description is a single, front-loaded sentence with no filler: 'Fetch a public robots.txt and return group counts only.' Each phrase narrows scope—resource, access level, verb, and output restriction—making it highly concise and easy to parse.

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

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

For a tool with nine parameters and no output schema, the description is too thin. It does not tell the agent how to map a host or URL to the robots.txt fetch, and there is no mention of what 'group counts' means in return terms. The mismatch between the focused 'robots.txt' description and the broad generic parameter list leaves a meaningful reasoning gap for correct invocation.

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

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

Schema description coverage is listed as 100%, so the granular per-parameter meaning is already in the schema. The description itself, however, does not identify which of the nine parameters provides the robots.txt URL, leaving some ambiguity when connecting the description to the actual inputs. This meets the baseline but 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 names a specific resource and action: 'Fetch a public robots.txt and return group counts only.' This clearly separates the tool from generic web-fetch and status-check siblings by limiting both the resource kind and the returned 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?

There is no explicit guidance on when to use this tool over siblings like web-fetch or fetch-status. The description only states what it does, not when it is preferred or when a different tool should be chosen. The phrase 'return group counts only' slightly implies it is for counting groups, but the absence of exclusions or alternatives makes this weak.

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. 'Key discarded' only says the input is not persisted, and this adds little because each schema parameter already says it is discarded. The description does not reveal side effects, return values, permission requirements, or whether the check is local.

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, at the lower cost of front-loading the main purpose. But 'Key discarded' is almost redundant with the schema's per-field discarding notes, and the brevity leaves important context out, so this is under-specification rather than efficient 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 validation tool, is no output, params, no return format, no indication of which param is the key, no mutual exclusivity rules, and no explanation of valid shape. The description alone is not enough to invoke 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%, which gives a baseline of 3, but the description's 'Key discarded' does not map to any of the nine schema properties—none of which is a Jira key. Rather, than helping the agent understand which parameter to pass, the description actively conflicts with the input shape and makes correct invocation harder to infer.

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 first sentence states a specific action and resource: 'Check a Jira issue key shape,' which does distinguish it from sibling shape tools like domain-shape and github-repo-shape. However, the input schema contains no parameter named 'key,' so the stated resource is not directly addressable, weakening the purpose clarity.

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

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

There is no guidance about when to use this tool over alternatives, no mention of conditions that favor it, and no exclusions. Sibling tools include similar 'shape' checkers, yet the description never tells an agent how to choose among them.

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 does not mention whether the tool performs a validation, returns a string, or has side effects. The parameter descriptions hint at 'shape checks' and discarding values, but the tool description itself remains silent on what actually happens.

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, which might appear concise, but it is under-specified rather than appropriately sized. With 9 parameters and no output schema, the description fails to provide any operational detail, making its brevity a deficiency rather than a virtue.

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

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

Given the tool's complexity (9 optional parameters, no output schema, no annotations), the description is completely inadequate. An agent would have no idea what the tool does with the parameters or what to expect as a result, making it impossible 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?

All 9 parameters have individual schema descriptions (100% coverage), so the baseline is 3. The tool description adds no extra parameter-specific meaning, but the schema already explains each parameter's role (e.g., 'Git ref name; discarded after the shape check'). However, the absence of a clear tool purpose leaves the overall parameter semantics 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 'ISO 639 language tag lv.' is a bare phrase that does not state an action, a resource, or a use case. It essentially restates the tool name and the language code, providing no verb to indicate what the tool does (e.g., validate, return, check, normalize). It fails to distinguish this tool from the 28 siblings in any meaningful way.

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

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

There is no guidance about when to use this tool versus alternatives. The description does not mention any context, prerequisites, or exclusions, and does not reference any of the sibling tools. An agent has no way to infer under what circumstances this tool should be selected.

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 mentions 'Body discarded' but does not disclose other behaviors such as side effects, or that the tool appears to handle multiple unrelated parameter types; no annotations are provided to fill the 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 brief and to the point, consisting of one sentence with no unnecessary words.

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

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

The description does not specify the output format, error handling, or how to use the multiple parameters; it only mentions the HTTP status aspect, leaving many contexts unexplained.

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 does not add meaning to the parameters; it only repeats the HTTP status focus while ignoring the other parameters' purposes. The schema descriptions already cover individual 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 ('HTTP status for a public library docs URL') but this does not align with the diverse parameters (city, timezone, etc.), making the actual 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 on when to use this tool versus alternatives; the description does not mention any conditions or comparisons with sibling tools.

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

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

There are no annotations, so the description carries the behavioral disclosure burden. “Values discarded” is a useful disclosure that inputs or values are not retained, but the description does not explain behavior on malformed JSON, whether the count is top-level only, what invalid input does, or how errors are surfaced.

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, front-loaded with the verb and object, and both sentences earn their place. There is no filler or redundant restating of the tool name.

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 annotations, no output schema, and no usage flow, the description is insufficiently complete. It does not tell the agent which parameter to pass the JSON in, what the return count means, or how to handle edge cases; agents must infer most behavior from the schema.

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

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

The input schema already describes all 9 parameters, so this is a baseline 3. The description adds “JSON object” context, which hints at the `json` parameter, but it does not explicitly map the described JSON object to that parameter or clarify how the other parameters are ignored or involved.

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 adds the behavior “Values discarded.” It is clear enough to distinguish from validate-json or fetch-focused siblings, but it does not explicitly mention the top-level vs nested scope of counting, so it is not a perfect statement of 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 gives no guidance about when to use this tool versus validate-json, domain-shape, or other sibling tools. There is no ‘when to use’, ‘when not to use’, or reference to an alternative tool.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. It does reveal that query and fragment are dropped, which is useful, but it completely ignores the other eight parameters in the schema. The param descriptions indicate many are 'discarded', but the tool description does not explain the overall behavior for non-URL inputs, leaving the agent uncertain about side effects or return formats. This is insufficient 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 two sentences, concise, and front-loaded with the core action. It wastes no words. However, given the complexity of the schema (9 parameters), it is arguably too terse and omits crucial information about the other parameters, making it slightly underwhelming despite its efficiency.

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

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

For a tool with 9 parameters, no annotations, and no output schema, the description is markedly incomplete. It only addresses the URL use case and ignores the other parameters, leaving the agent without understanding how to treat inputs like city, zone, json, or feed. The description fails to explain the tool's overall scope or what happens when non-URL parameters are supplied, making it inadequate for reliable invocation.

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

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

Schema description coverage is 100%, so every parameter is individually described. The tool description adds specific meaning to the 'url' parameter (origin, host, path, query/fragment dropping) that goes beyond the schema. However, it adds nothing for the other eight parameters, which are already described in the schema. Since the schema handles the basic semantics and the description enriches only one parameter, a 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 action ('Return origin, host, and path for a URL') with a specific resource and outcome. It is not a tautology and distinguishes itself from sibling checker tools like browser-url-ok or domain-shape by focusing on extraction rather than validation. However, it does not explicitly compare itself to alternatives, so it lacks sibling differentiation despite obvious intent.

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

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

No guidance is provided on when to use this tool instead of the many URL-related siblings (e.g., browser-url-ok, fetch-status, web-fetch). The description implies URL normalization but never states exclusions or alternative conditions. An agent is left to infer that this is for extracting components, which is not explicit enough given the crowded 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?

With no annotations, the description carries the full burden. It discloses that no browser is launched, but omits whether a network request is made, what success or failure looks like, and whether any side effects occur.

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

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

The description is brief and free of filler; two sentences deliver the core purpose and one important caveat. However, brevity comes at the cost of missing necessary details.

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

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

Given the confusing, high-parameter input schema and no output schema, the description is substantially incomplete. It does not explain the return type, expected input, or behavior beyond the negative browser statement.

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 adds no meaning to the input schema. The nine optional properties have unrelated, boilerplate descriptions (e.g., 'discarded after the shape check'), and the description does not indicate which parameter is the URL to check.

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 behavioral caveat ('No browser is launched'), but it does not identify which of the nine input properties is the URL or clarify what 'can be opened' means. Sibling tools like browser-url-ok, fetch-status, and web-fetch create 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?

There is no guidance on when to use this tool over alternatives such as browser-url-ok, fetch-status, or web-fetch. The description only states a negative behavior and does not provide selection criteria.

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

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

With no annotations present, the description carries the behavioral burden. 'Query discarded' appropriately discloses that the query text is not retained after the call, which is useful. However, it does nothing to disclose how the other 8 parameters are handled, whether multiple inputs cause an error, or whether the output is simply an integer; the transparency is only partial.

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

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

The description is two short sentences, front-loaded with the primary action and immediately adding the most important side-effect note. It contains no filler or redundancy, making it appropriately concise for the simple function name.

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 annotations, and no output schema, but the description only says 'Count characters in a search query. Query discarded.' It doesn't clarify how to choose among the many string fields, whether multiple can be passed, how the result is returned, or why the other parameters are present. For an agent to use this tool correctly, this gap is significant.

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

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

Schema description coverage is 100%, so the schema already describes each parameter. The description adds almost nothing beyond picking out 'search query' and noting it is discarded. It does not clarify which of the exposed fields is actually counted, nor whether the others are ignored, leaving a semantic gap despite the high coverage.

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

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

The description clearly states the action: count characters in a search query, with 'Query discarded' giving additional scope. However, it does not explicitly differentiate from sibling counting tools like hn-front-count or memory-key-count, though the underlying purpose is understandable.

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

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

There is no guidance on when to use this tool versus any alternative, nor any mention of when not to use it. The tool schema exposes 9 optional parameters, but the description does not specify which parameter (query only?) is intended, let alone how it relates to other tools with similar shape or count behavior.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'catalog', implying a read-only reference, but does not explicitly state whether it returns a list, a single code, or how the 9 input parameters are used. The mismatch between the description and the wide-ranging parameters (ref, url, city, etc.) is unexplained, leaving 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 a single sentence, which is concise and front-loaded. However, for a tool with 9 parameters and no output schema, this brevity borders on under-specification. The sentence states the purpose but lacks any structure or supplementary sections (e.g., examples, notes). It earns a 3 because it is efficient but not well-rounded.

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 required fields, no output schema, and no annotations. The description must compensate by explaining what the tool does with these inputs, what it returns, and any constraints. A one-line statement about a 'catalog' is completely inadequate for an agent to call this tool correctly. This is a severe gap in 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 has a description. The tool description adds no meaning beyond the schema—it does not connect the parameters to HTTP status codes or any function. Since the schema already documents each parameter's individual purpose (e.g., 'discarded after the shape check'), the baseline of 3 is appropriate; the description contributes no additional 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 'Short catalog of common HTTP status codes' clearly states the resource (HTTP status codes) and the action (provides a catalog). It is specific enough to convey the tool's core function. However, it does not distinguish this tool from siblings like fetch-status or browser-url-ok, which could also involve HTTP status codes, so it loses a point for lacking sibling differentiation.

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

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

The description gives no indication of when to use this tool versus alternatives. It does not mention prerequisites, typical use cases, or when to prefer another tool. There is no guidance on exclusions or alternatives, so an agent must infer usage entirely from the tool name and schema.

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

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

The description does expose one behavioral trait: 'Prompt discarded', indicating the input is ignored. Yet with no annotations, the description carries the full burden, and it says nothing about side effects, return structure, or deterministic behavior. The schema descriptions mention 'no disk access' and 'discarded after check', but the tool-level description remains insufficiently 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 very short—two sentences—and puts the main purpose first, followed by the input-discard note. It is efficient, but the brevity is so extreme that key clarity is lost; it would earn a 5 only if the briefness did not hurt understanding.

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 or annotations exist, so the description must explain the returned template on its own. It merely says 'three-step thinking template' without defining the steps or format. With nine optional parameters presented as unused, an agent has little idea of what the tool does or when it is meaningful.

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

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

All 9 parameters have 100% description coverage in the schema, so the structured field provides the necessary meaning. The tool description adds no parameter semantics and does not clarify which of the 9 should ever be passed. Under the baseline rule for full schema coverage, a score 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 clear action ('Return a three-step thinking template') with a specific resource, and none of the 28 sibling tools mention templates, so it appears distinct. However, 'thinking template' is still a vague term and not explicit about what the template contains, preventing a perfect score.

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 invoke this tool, no context, and no mention of alternatives like the many sibling tools. The phrase 'Prompt discarded' says something about handling input but does not help an agent decide to call this tool versus others. A tool with this broad parameter set needs more direction.

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 the basic function and gives no information about output format, error handling, or side effects.

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

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

The description is a single concise sentence with no unnecessary words. It is appropriately sized and front-loaded with 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's schema includes 9 parameters, but only 'zone' appears relevant. The description gives no indication that other parameters are ignored. There is also no output schema or description of return format, leaving agents under-informed about how 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?

The input schema has 100% description coverage for all 9 parameters, so the baseline is 3. The description adds nothing beyond linking 'named IANA timezone' to the 'zone' parameter, which the schema already explains. No extra meaning is provided.

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

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

The description 'Current time in a named IANA timezone' states a specific verb and resource, clearly distinguishing it from siblings like utc-time and iana-zones. An agent can grasp the tool's purpose at a glance.

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 does not mention conditions, exclusions, or when to prefer another time-related tool.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state that the nine parameters are ignored or discarded, whether the tool has side effects, what the output format is, or whether parameters affect the result.

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

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

The description is very short and front-loaded with the key purpose. No fluff or redundancy. It could be expanded with parameter relevance, but brevity itself is not the problem.

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

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

The tool has nine optional parameters, no annotations, and no output schema. The description fails to explain why these parameters exist, whether they affect the result, or what the return value looks like. This is incomplete for the complexity 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?

Schema description coverage is 100%, so the schema already documents each parameter, including the fact that most are discarded. The description adds no additional meaning about how the parameters relate to the timestamp output.

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 that the tool returns the current UTC timestamp, using a specific verb and resource. It doesn't explicitly distinguish itself from sibling time-related tools like 'timezone' or 'iana-zones', but the core purpose is understandable.

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

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

There is no guidance on when to use this tool versus alternatives, no context about why it has nine unrelated parameters, and no hints about when it should be preferred. The agent is left entirely to infer usage.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that the body is discarded, which is one useful trait, but it omits the return value (e.g., boolean vs. error), error handling, or that the other eight parameters are ignored. This is insufficient for an agent to anticipate tool 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, which is generally good, but it's too brief to be useful. It has no structure, no front-loading of critical info, and the single sentence does not earn its place as it only restates the obvious from the name.

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 a 9-parameter schema with no output schema and no annotations. The description is grossly incomplete: it doesn't specify which parameter is validated, what the tool returns, or how errors are surfaced. An agent cannot safely invoke this 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?

Although schema coverage is 100%, the description adds no parameter meaning. It fails to map 'body' to the 'json' parameter or explain the roles of the other eight parameters. The schema descriptions stand alone, and the description adds confusion rather than clarification.

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 validates JSON and discards the body, which is a specific verb+resource. However, 'body' is ambiguous—it doesn't identify which of the nine schema parameters represents the JSON to validate. The purpose is clear but not fully tied to the schema.

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

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

No guidance is given on when to use this tool versus alternatives. The description doesn't mention any conditions, exclusions, or related tools, leaving the agent to infer suitability 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?

No annotations are provided, so the description must fully disclose behavior, but it only mentions the primary weather use case. The input schema includes 9 unrelated parameters (e.g., ref, url, feed, json, path, zone) whose descriptions indicate they are 'discarded after checks' or used for other purposes, implying the tool may have additional modes. This is never disclosed, so an agent cannot predict the tool's behavior for other inputs. It also omits any side effects, output format, or API 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 fluff. It immediately states the core function and data source, earning its place. However, it is too terse given the tool's apparent multi-parameter nature, sacrificing 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?

The tool has 9 optional parameters, no output schema, and no annotations. The description only covers the city/temperature case, leaving the other 8 parameters unexplained. An agent cannot know what the tool returns or how to correctly invoke it for non-weather cases. This is a severe gap for a tool with 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 each parameter already has a description. The tool description adds no extra meaning for any parameter, staying at the baseline 3. It does not clarify how the 'city' parameter interacts with the others or which parameters trigger the weather hint.

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-resource: 'Current temperature for a city' with the data source 'Open-Meteo'. It clearly differentiates from sibling tools (e.g., geo-hint, timezone) that handle other location or time concepts, making the primary function unmistakable.

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. There is no mention of scenarios where other tools would be preferred, nor any preconditions or examples. The description only states what it does, leaving usage entirely to inference.

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

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

With no annotations, the description carries the full burden. It discloses that for a URL the body is discarded, but it never mentions that for other parameters (json, city, path, etc.) the tool performs different checks and discards inputs. This is misleading—an agent would assume the tool only handles URLs, missing the broader behavior entirely.

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, which is efficient in structure. However, it is under-specified: it omits the majority of the tool's functionality, making it misleading rather than helpfully concise. It front-loads the URL behavior but fails to cover the other eight parameters.

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

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

Given the tool's complexity (9 optional parameters, no output schema), the description is grossly incomplete. It explains only the URL path and says nothing about the behavior for the other parameters, the return format for each, or how they relate. An agent cannot correctly decide which parameter to provide or what output to expect.

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

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

Schema description coverage is 100% and each parameter has a meaningful description (e.g., 'Git ref name; discarded after the shape check'). The tool description adds no additional meaning beyond the schema, but the schema itself is informative, 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 clear verb and resource ('HTTP status and content type for a public URL') but omits the tool's other eight distinct functions (city, json, timezone, etc.). It misleads by presenting a single-purpose tool when the schema reveals multiple unrelated checks, and it does not clearly distinguish from siblings like 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 on when to use this tool versus alternatives such as validate-json, geo-hint, or fetch-status. No mention of mutually exclusive parameters or selection criteria. The description lacks any context about the intended dispatch or when each parameter applies.

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 'Title discarded after the call' gives a small amount of behavioral information about data retention, but it does not disclose whether the tool performs a network request, whether it is read-only, how errors are surfaced, or what side effects might occur. With no annotations, the description carries the full burden, and these behavioral traits remain 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 brief and well-structured, with the main purpose in the first sentence and an extra behavior note in the second. While it is concise, the second sentence is light on actionable detail and leaves several important execution 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?

Given the 9 optional inputs, missing annotations, and no output schema, the description is far too thin to be complete. It does not state what the tool returns, which parameters to pass for the title check, or how it behaves in case of missing, invalid, or unretrievable titles.

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

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

The input schema documents all 9 parameters, so baseline credit is fair, but the description does not map the central 'Wikipedia title' input to any of the parameters. In fact, the schema contains no title field, so the description adds no parameter semantics that help the agent decide which argument should carry the title.

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 that the tool checks whether a Wikipedia title exists, using a specific verb and resource. However, it does not clarify how the title is supplied through the 9 provided parameters, leaving a gap between the stated purpose and the actual callable inputs.

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

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

There is no guidance on when to use this tool instead of alternatives such as browser-url-shape, validate-json, or web-fetch. No context is given about preconditions, expected inputs, or situations where another tool would be more appropriate.

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