Public suffix count

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

The description explicitly states that task text is discarded and that the tool returns connection methods, which provides some transparency about data handling and output. However, with no annotations, it does not mention network effects, authentication, rate limits, failure behavior, or whether any external services are contacted.

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

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

The description is extremely concise, with two short sentences that communicate purpose and a key behavioral detail. No filler or redundant information is present.

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

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

The description is brief and leaves some gaps: it does not describe the structure of the 'connection methods' return value, error cases, or how the examples map to parameters. Given the simple optional-parameter surface and no output schema, it is adequate but not fully 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?

The input schema already provides 100% parameter coverage with individual descriptions. The main description does not add much semantic meaning beyond the schema, but the schema descriptions are self-explanatory enough to reach the baseline.

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

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

The description clearly identifies the main action ('Find') and the resource ('public pay-per-call tool gateway'), and gives useful task examples such as weather, search, scrape, or voice. It is slightly ambiguous what 'gateway' means and how it differs from direct sibling tools like weather-hint or web-fetch, 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?

The description gives examples of when the tool might be used, but does not explain when to prefer this tool over siblings or when not to use it. There are no explicit usage conditions, alternatives, or contextual cues beyond the listed task types.

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

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

With no annotations, the description carries the transparency burden, but it only reveals that no browser is launched. It does not disclose whether the tool makes a network request, what 'can be opened' means, what side effects occur, or what the return value looks like.

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

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

The description is a single clear sentence and is not padded. The schema is compact and well-structured, with no redundant prose.

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 explain the return format, failure behavior, or how the many optional parameters relate to the stated purpose. Given nine optional parameters and no output schema, the tool is under-specified for reliable use.

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

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

Although every parameter has a schema description, many descriptions are unrelated or contradictory to the tool purpose: 'url' is described as 'HTTPS URL to normalize or cite,' and city/feed/json/zone/query parameters are labeled 'discarded' or irrelevant. An agent cannot confidently determine which parameter to supply for the URL 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 and resource: 'Check whether a URL can be opened.' The additional clause 'No browser is launched' clarifies the check is non-browser and differentiates from sibling browser-based tools like playwright-url-ok.

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

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

The description does not specify when to use this tool instead of alternatives such as normalize-url, fetch-status, or playwright-url-ok. The only hint is 'No browser is launched,' which weakly implies a lightweight check, but no explicit use cases or exclusions are given.

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

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

With no annotations provided, the description carries the full burden, but it only mentions that the expression is discarded. It does not disclose side effects, permissions, output behavior, or error conditions.

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 main action. The second sentence is ambiguous but does not add unnecessary length or clutter.

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

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

Given nine parameters and no output schema, the description is far too sparse. It omits the return format, which parameter to supply, example usage, and any edge-case behavior, so an agent cannot reliably call 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?

The schema lists nine unrelated string parameters, none of which is an arithmetic expression or operand. The description does not explain how any parameter maps to 'a+b', making parameter usage effectively impossible 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 description states a clear action ('Evaluate a+b style arithmetic') and the tool name reinforces it, but 'Expression discarded' is ambiguous and no expression parameter appears in the schema, leaving the intended operation partially 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 guidance is given on when to prefer this tool over siblings or when not to use it. The arithmetic phrasing implies a use case, but there is no concrete context or alternative comparison.

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

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

With no annotations, the description carries the transparency burden. It discloses that page content is not stored, but it does not mention that most schema parameters are discarded, nor does it explain side effects, error behavior, or whether a real HTTP request is made.

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 main operation and followed by a key limitation. There is no redundancy or wasted wording.

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

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

Given the tool has nine parameters, no output schema, no annotations, and many sibling tools, the description is too sparse. It does not explain the output format, the role of the non-url parameters, or how it differs from similar URL/status tools.

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

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

Schema descriptions cover all parameters, so the baseline is 3. The overall description clarifies only the url-related purpose but does not add meaningful guidance about the many seemingly unrelated parameters or which ones actually influence the result.

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

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

The description clearly states the tool returns host, scheme, and HTTP status for a URL, and distinguishes itself by noting page content is not stored. However, the title is null and the intended use case is only implicitly separated from sibling tools like fetch-status or normalize-url.

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

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

The description does not explicitly state when to use this tool versus alternatives such as web-fetch, fetch-status, or browser-url-ok. It only implies non-storage of content, which is weak guidance for selection.

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

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

The only behavioral claim is 'No identifiers are retained,' which addresses privacy but not what the tool actually does with inputs, whether it accesses external resources, or what side effects may occur. With no annotations, the description carries the full burden and falls short.

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 contains no filler or redundant phrases. Both sentences provide some information, but the extreme brevity contributes to ambiguity even though the structure itself is 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?

With 9 optional parameters, no output schema, and no annotations, the description is far too incomplete. It never explains what 'classified' means, what output the agent should expect, or how the many parameters relate to the tool's purpose.

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

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

The description itself adds no parameter-level meaning beyond the input schema. However, schema description coverage is 100%, so the baseline of 3 applies even though the tool description does not clarify how each parameter contributes to classification.

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

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

The description says 'Show how this request is classified' but never defines what classification means or what compatibility refers to. It lacks a clear resource or outcome, and does not distinguish the tool from siblings like fetch-status or validate-json.

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. The description provides no conditions, use cases, or examples, so an agent cannot determine when compatibility should be invoked.

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

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

With no annotations, the description must carry behavioral disclosure. It only states that WHOIS/ownership data is not included; it does not mention whether network access occurs, how output is formatted, what happens on invalid input, or whether any state is changed.

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 and is front-loaded with the main action. It loses some structure by adding an unfocused negative qualifier, but it is not bloated.

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 output schema, and no annotations, yet the description does not identify the required input, expected output, error behavior, or relationship to sibling tools. This is too incomplete for an agent to invoke reliably.

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

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

Although schema description coverage is 100%, most parameter descriptions are unrelated to splitting a hostname (e.g., 'City name for a public weather hint', 'JSON text to validate') and do not clarify which field should be used. The description adds no cross-parameter meaning.

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 ('Split a hostname into labels'), but the qualifier 'without WHOIS or ownership data' is ambiguous and the input schema includes many unrelated optional fields (city, feed, json, path, zone, query), so the actual purpose is not confidently distinguishable.

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 when-to-use guidance is given, and there is no comparison to sibling tools such as public-suffix or normalize-url. The phrase 'without WHOIS or ownership data' is the only usage hint, which is not sufficient to route an agent correctly.

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 full responsibility for transparency. It accurately describes the network operation (HEAD request), the scope (public URL), and the limited return (status only), which is honest and sufficient for an agent to understand 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 extraneous words. It front-loads the essential information (method, target, return) and is perfectly 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 clearly states the core function, but it does not address the unusual mix of unrelated parameters (city, zone, query, etc.) in the schema. An agent might be uncertain why those parameters exist, though the schema descriptions partially compensate. Overall context is adequate but not fully 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?

The schema descriptions cover 100% of parameters, each with a clear purpose. The tool description itself adds no parameter-specific guidance, but the schema already provides adequate semantics, so the baseline of 3 is appropriate.

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

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

The description clearly states the action (HEAD), the target (public URL), and the exact output (status only). This distinguishes it from content-fetching tools like web-fetch, and the verb 'HEAD' is precise.

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

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

The description implies usage for public URLs and status-only needs, but it does not explicitly state when to prefer this over similar siblings like browser-url-ok or playwright-url-ok, nor does it mention any alternatives or exclusions.

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

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

No annotations are provided, so the description must carry the behavioral burden. It only mentions 'Path discarded' and several parameter descriptions say 'discarded', but the description does not explain side effects, validation behavior, return values, or what the tool actually does with the provided parameters.

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

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

The text is very short and front-loaded with a verb, but it omits essential behavioral information and ends with an ambiguous fragment. A concise description should still clarify the tool's core function, which this one fails to do.

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

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

With no output schema and a description that does not explain the purpose of nine optional parameters, the tool is far from contextually complete. The description does not mention return format, validation criteria, or how the Figma URL should be shaped, leaving an agent unable to confidently invoke it.

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

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

All nine parameters have descriptions, which gives high schema coverage, but many descriptions are unrelated to Figma URL parsing and repeatedly say values are 'discarded', which adds confusion rather than semantic clarity. The incoherence between the tool name and the parameter set prevents a higher score.

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

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

The description states an action and object ('Parse a Figma file URL'), but the input schema contains numerous unrelated parameters (city, feed, zone, query) and the phrase 'Path discarded' is ambiguous—it could refer to the URL path or the separate 'path' parameter. The mismatch between the stated purpose and the actual schema makes the tool's 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?

The description provides no guidance on when to use this tool, how it relates to sibling tools such as normalize-url or domain-shape, or what conditions warrant calling it. No examples, prerequisites, or alternative-selection criteria are given.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'No disk access,' which is a useful constraint, but it does not explain what 'looks safe' entails (e.g., syntactic validation, format checks, or pattern matching) or what happens on invalid input, leaving significant behavioral ambiguity.

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

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

The description is a single, succinct sentence that avoids fluff and directly states the core action and constraint. It is appropriately brief for a tool of this apparent simplicity, though the brevity contributes to missing contextual 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?

Despite having a simple core function, the tool has 9 optional parameters and no output schema, yet the description provides no context on how to invoke the tool, what inputs are expected, what 'safe' means, or how results are returned. The mismatch between the description (focusing on path) and the schema parameters (covering refs, urls, cities, etc.) makes the tool under-specified, leaving critical usage details 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?

Schema description coverage is 100% because every parameter has a description, but those descriptions are generic and mismatched to the tool's stated purpose (e.g., 'Git ref name' for `ref`, 'HTTPS URL' for `url`). The tool description adds no further meaning beyond the schema; it does not clarify which parameters are relevant for path safety checks or how they relate to `path`. Since the schema already provides descriptions, the baseline of 3 applies, with no additional value from the tool description.

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

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

The description clearly states the tool's purpose: to check whether a path looks safe, with the additional specification that it does not access the disk. This distinguishes it from tools that actually perform filesystem operations, but it does not explicitly differentiate from sibling tools that might also validate paths in a non-disk manner.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention any conditions, alternatives, or situations where this tool is preferred, leaving the agent to guess its appropriate usage context.

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

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

With no annotations, the description carries the burden of explaining side effects and dependencies. It only says the operation is 'via Open-Meteo', implying an external geocoding lookup, but it does not disclose whether the call is read-only, whether data is retained, or how failures or rate limits are handled.

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, direct sentence with no fluff or redundant restatement of the tool name. It is well structured for quick parsing, though the terseness hides the input ambiguity.

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

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

There is no output schema, no required parameter, and no explanation of the coordinate format or ordering. Given nine optional properties with contradictory descriptions, the tool context is too incomplete for an agent to confidently pass the right input and interpret the result.

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?

Every parameter has a description, but most are semantically mismatched with geocoding: url, feed, host, json, path, ref, zone, and query reference URLs, feeds, JSON validation, file paths, refs, timezones, and search-length checks. Only city and query could plausibly carry a place name, yet their descriptions are framed around weather hints and length checks rather than coordinates.

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 function—returning latitude and longitude for a place—and identifies the external service Open-Meteo, making it distinguishable from sibling tools like weather-hint and timezone. It is less clear which input property actually supplies the place, since the schema includes many unrelated optional fields.

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 invoke this tool instead of related lookup tools, nor is there an example, required-parameter note, or explanation of how to choose among the optional fields. The only usage signal is the verb phrase in 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, and the description only says 'Parse owner and repo'. It does not disclose whether the tool is read-only, how it handles invalid URLs, what errors may occur, or what the output looks like.

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

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

The description is a single focused sentence with no unnecessary words. It is well-structured and immediately understandable.

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

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

The description is far too minimal for a tool with nine parameters and no output schema. It leaves critical gaps around expected input, output format, error behavior, and relationship to sibling tools.

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

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

The schema includes nine parameters, but only 'url' appears relevant to the stated purpose. Several parameter descriptions (e.g., 'city', 'feed', 'zone') are unrelated to parsing a GitHub URL, creating confusion about which parameters actually matter.

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

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

The description clearly states the exact operation: parse owner and repo from a GitHub URL. It also implicitly distinguishes this tool from sibling shape tools like domain-shape and jira-key-shape.

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

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

No usage guidance is provided. The description does not mention when to choose this tool over alternatives, nor does it specify which input parameter should be used with the GitHub URL.

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 disclosing side effects, permissions, and edge cases. It only mentions 'Titles discarded,' which is ambiguous and does not clarify that all input parameters are ignored or that the tool is read-only.

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

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

The description is exceptionally brief and front-loaded with the primary action and target. It wastes no words and immediately conveys the core purpose.

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

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

For a simple counting tool, the description is mostly sufficient (it implies a numeric output). However, it ignores the glaring mismatch between the tool's purpose and the input schema, leaving the agent confused about parameter relevance and whether certain inputs are intentionally ignored.

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

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

The description does not explain how the nine optional parameters relate to counting Hacker News stories, and the schema descriptions themselves are unhelpfully generic (e.g., 'Git ref name; discarded after the shape check'). Since the tool clearly needs no input to count front-page stories, the description leaves the agent uncertain about whether to pass anything.

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

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

The description clearly states the action (count) and the resource (current Hacker News front-page stories). It does not directly compare to siblings, but no sibling exists for this specific counting task, so the purpose is adequately distinguishable.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any specific use cases, prerequisites, or why one would call this over other tools like fetch-status or web-fetch.

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

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

The description does not state what the tool returns, what errors may occur, or what side effects exist; the param notes say some values are 'discarded', but the actual behavior is still opaque.

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

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

The description is very short and free of fluff, but it is too sparse to convey structure or usage, so it earns only a middle 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 nine optional parameters and no output schema, the description provides almost no context about inputs, outputs, or intended scenarios.

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

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

Each parameter has a schema description, but most appear unrelated to timezone names (e.g., git ref, RSS feed, JSON text) and the descriptions do not clarify why they are accepted or how they relate to the tool's purpose.

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

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

The description names a resource ('common IANA timezone names') and a context ('clock calls'), but it lacks an action verb, so it is unclear whether the tool returns, validates, or filters zones.

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

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

There is no guidance on when to prefer this tool over the sibling 'timezone' tool or any other alternative; the only hint is the phrase 'for clock calls'.

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 to provide behavioral context, and the description only states the basic action. It does not disclose potential side effects, network usage, error handling, or what happens if the robots.txt is missing or inaccessible.

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

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

The description is a single concise sentence that directly conveys the core functionality without unnecessary verbosity. It is well-structured 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?

Without an output schema or further explanation, the tool's expected output format is vague ('group counts only'). Moreover, the ambiguous parameter descriptions leave the user unsure how to request a specific robots.txt, making the overall context incomplete.

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

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

While the schema covers 100% of parameters, the descriptions are generic and clearly misaligned with the tool's purpose (e.g., 'url' described as 'HTTPS URL to normalize or cite' and 'ref' as 'Git ref name; discarded after the shape check'). These are placeholder-like descriptions that actively mislead rather than clarify how to specify the target robots.txt.

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

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

The description clearly states the tool's purpose: to fetch a public robots.txt and return group counts. It specifies the action (fetch) and the resource (robots.txt), making the intent unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives like fetch-status or normalize-url. The description does not mention any distinguishing conditions or scenarios where this tool is preferred.

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

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

With no annotations, the description bears the full burden of explaining side effects and behavior. 'Key discarded' hints that the input is not retained, but the description does not say whether the tool is read-only, what it returns, or whether it performs any external lookup or validation beyond shape checking.

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 and front-loaded, but it omits essential information. It is concise in word count yet lacks the minimal structural details needed to understand how to call the tool or interpret its result.

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

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

Given nine optional parameters and no output schema, the description does not provide enough context to know which parameter to use, what input format is expected, or what the tool returns. It is incomplete for reliable agent use.

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

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

The schema descriptions are generic and do not map to a Jira issue key: ref, url, city, feed, host, json, path, zone, and query are all unrelated to the stated purpose. Despite 100% schema description coverage, no parameter is described as the Jira key, so the parameter semantics are effectively useless for this tool.

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

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

The description names a specific action and resource: 'Check a Jira issue key shape.' However, the input schema contains no 'key' parameter, so it is unclear which of the nine unrelated optional fields actually supplies the Jira key. The phrase 'Key discarded' adds ambiguity rather than resolving how the tool is invoked.

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

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

The description gives no guidance about when to use this tool instead of sibling tools such as domain-shape, figma-url-shape, or github-repo-shape. It also does not mention any scenarios, prerequisites, or context where a Jira key shape check would be appropriate.

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

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

The only disclosed behavioral trait is that the body is discarded, which is useful but minimal. With no annotations present, the description should also mention side effects, limitations, or output format, but it does not.

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

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

The description is very short and front-loaded, with no unnecessary words. It clearly conveys the core action in two sentences, though this brevity comes at the cost of missing important contextual information.

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

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

With nine parameters, no required fields, no output schema, and no annotations, the description is far too incomplete to allow correct usage. It does not explain the input contract, the return format, or how to handle the many seemingly irrelevant parameters.

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

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

The schema has nine parameters, but their descriptions appear copied from unrelated sibling tools (e.g., Git ref, weather hint, JSON validation) and do not align with the stated purpose of checking a library docs URL. The tool description does not clarify which parameter is required or how the others relate to the operation.

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

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

The description states that the tool returns an HTTP status for a public library docs URL and discards the body, giving a basic sense of purpose. However, 'public library docs' is ambiguous and it does not clarify which of the nine input parameters is actually relevant, nor how it differs from sibling URL-status tools.

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

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

The description gives no guidance on when to use this tool versus alternatives such as fetch-status, browser-url-ok, or web-fetch. It does not state any conditions, preferences, or scenarios where this hint 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?

No annotations are provided, and the description only says 'Values discarded,' which hints at internal behavior but does not explain what is returned, how errors are handled, whether only top-level keys are counted, or whether there are side effects. The full burden of disclosure falls on the text, and it is insufficient.

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

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

The description is very short and to the point, with no unnecessary words. However, its brevity sacrifices necessary context about how the input relates to the operation, so it is concise but not fully 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?

The tool lacks an output schema and the description does not explain how to provide the JSON object, what the return value looks like, whether nested keys are counted, or what happens with invalid input. Given the unusual nine-parameter schema, this missing context makes the tool very difficult to invoke 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 lists nine optional parameters with descriptions that do not align with the stated purpose of counting keys in a JSON object. For example, 'json' is described as 'JSON text to validate; discarded after the check' rather than as the object whose keys should be counted. No parameter is clearly identified as the target JSON input.

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

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

The description clearly states the action ('Count keys in a JSON object') and resource ('JSON object'), but it does not specify how the JSON object is supplied via the input schema. The connection between the description and the nine optional string parameters is unclear, so the purpose is only partially actionable.

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 such as validate-json, search-query-len, or other sibling tools. No use cases, prerequisites, or conditions are mentioned.

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

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

With no annotations, the description is the only source of behavior. It discloses the output components and that query/fragment are dropped, but it does not mention error handling, invalid input behavior, or whether the numerous unrelated parameters are ignored.

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

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

The description is extremely concise, with two short sentences and no redundant wording. It is well structured for a simple tool.

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

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

Given the nine-parameter schema and lack of output schema or annotations, the description is too sparse. It does not clarify the roles of the extra parameters, the expected output format beyond field names, or edge-case behavior, so an agent cannot confidently invoke it correctly in all contexts.

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

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

The input schema contains nine parameters, but the description only relates to 'url' and possibly 'query'. Most parameters (ref, city, feed, json, path, zone) have descriptions that appear unrelated to URL normalization and are not explained in the tool description, making their semantics highly 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 clearly states the tool returns origin, host, and path for a URL and drops query/fragment. It uses a specific verb and resource, though it does not explicitly distinguish it from sibling URL-related tools.

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

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

No guidance is provided about when to use this tool instead of alternatives like browser-url-ok, fetch-status, or web-fetch. The description only states what it does, not when it 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?

Discloses that no browser is launched but does not describe the actual mechanism (e.g., HTTP request, DNS check) or side effects, leaving the 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, succinct sentence; the schema is well-structured, though the parameter descriptions are nonsensical.

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?

Lacks essential details such as return value, error behavior, example outputs, or how the parameters are used; the tool is underspecified for an agent to invoke 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 nine parameters have descriptions that are unrelated to checking URL openability (e.g., city, zone, json) and appear to be copied from other tools; they provide no coherent meaning for this tool.

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

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

The description states a clear verb and object for checking URL openability, but the input schema includes unrelated parameters that obscure the intended usage, so purpose clarity is only moderate.

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?

Provides no explicit guidance on when to use this tool versus siblings like browser-url-ok or fetch-status; the 'No browser is launched' hint is implicit but not sufficient.

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 is no information about side effects, permissions, return values, or error behavior. The description and annotations offer no transparency into what happens when the tool is invoked.

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?

While the description is extremely short, it fails to earn its place by conveying any meaningful information. It is less a concise summary and more an uninformative title. The structure provides no useful breakdown of purpose or usage.

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

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

Given the tool has 9 parameters and no output schema, the description is wholly inadequate for an agent to understand what the tool does, how to call it, or what to expect. The context provided by the schema does not compensate for the lack of descriptive content.

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

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

The schema descriptions are present but appear generic and disconnected from the tool's stated purpose. For example, 'Git ref name; discarded after the shape check' does not clarify how it relates to counting public suffixes. The descriptions do not explain how parameters affect the operation.

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

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

The description 'Public suffix count' is a noun phrase without a verb or action. It does not state what the tool does beyond a vague implication of counting something related to public suffixes. There is no indication of input, output, or behavior.

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

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

No guidance is provided on when to use this tool versus alternatives. The description gives no context about typical use cases, prerequisites, or situations where it would be appropriate.

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

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

The description does disclose that the query is discarded, which is a useful side-effect note. However, with no annotations, it does not clarify that the other eight listed parameters are ignored or that no external 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?

At just two short sentences, the description is extremely concise and every word adds information. It states the action and the disposal of the query without padding.

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

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

With nine optional parameters and no output schema, the description does not fully equip an agent to invoke the tool. It does not state the return type, how other parameters are treated, or what happens when no query is provided.

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

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

The schema already documents all parameters, so the description does not need to repeat them. It does point to 'search query' as the relevant input, though the presence of many unrelated parameters in the schema remains confusing.

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

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

The description states a specific action—count characters in a search query—so an agent can grasp the tool's core purpose. It does not explicitly distinguish from sibling tools, but the verb and object are clear enough.

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

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

No usage guidance is given for when to use this tool versus alternatives, nor how the query should be supplied. The only additional note is that the query is discarded, which is more about side effects than usage 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, the description carries the full burden of explaining behavior. It only says 'short catalog' and does not disclose whether the inputs affect the result, whether it performs any network/disk access, or what the output shape is.

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

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

The description is a single short sentence and is easy to read, with no padding or repetition. It is concise but sacrifices necessary detail.

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

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

There is no output schema and no annotations, and the description does not cover return format, parameter roles, error behavior, or scope. A tool with nine optional parameters and no explanation of their relevance is materially incomplete.

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

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

Although every parameter has a schema description, those descriptions are unrelated to HTTP status codes: git refs, URLs, city names, feeds, hosts, JSON text, file paths, timezone names, and search text. The description does not explain how any of these optional parameters would influence the catalog result.

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 the resource ('common HTTP status codes') and indicates a 'short catalog', so the core purpose is recognizable. However, it lacks an explicit verb or statement of what the tool returns (e.g., whether it lists all codes or looks one up), and the unrelated input parameters blur the purpose.

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

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

No guidance is given about when to use this tool instead of related siblings such as fetch-status, browser-url-ok, or web-fetch. The description provides no conditions, examples, or exclusions.

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

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

With no annotations, the description carries full responsibility for disclosing behavior. It does mention that the prompt is discarded, which is a useful detail, but it omits side effects, return format, errors, and whether all parameters are ignored.

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 no filler. It loses a point because the dangling 'Prompt discarded' clause makes the structure slightly confusing.

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

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

For a tool with 9 parameters and no output schema, the description is far too sparse. An agent cannot tell what the three-step thinking template looks like, how to invoke the tool meaningfully, or what to expect in the response.

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 description explicitly says it is discarded after some check, which is an unusual but clear semantic. The descriptions do not go beyond the schema, but they sufficiently indicate that inputs do not affect the returned template.

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

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

The description states a clear action and resource: 'Return a three-step thinking template.' However, it does not explain what the template contains or how it relates to the tool's name, and the clause 'Prompt discarded' adds ambiguity about whether the tool processes any input.

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

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

No guidance is provided about when to use this tool instead of any of the 27 siblings. There is no mention of alternatives, conditions, or concrete use cases.

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

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

With no annotations, the description carries the burden of explaining behavior, but it only says what the tool returns and does not address side effects, errors, permissions, or edge cases like invalid timezone names.

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

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

The description is a single concise sentence that immediately states the tool's core function 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?

Despite having nine parameters and no output schema or annotations, the description only covers the core purpose. It fails to clarify which parameters are actually relevant, making the overall context incomplete.

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

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

Schema coverage is 100%, so baseline is 3. The tool description adds no parameter-level meaning beyond the schema, and the schema includes many unrelated fields that the description does not help disambiguate.

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

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

The description clearly states the tool returns the current time for a named IANA timezone, which distinguishes it from siblings like utc-time and iana-zones.

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

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

No explicit guidance is given about when to use this tool versus alternatives such as utc-time, nor are any conditions or prerequisites mentioned.

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

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

No annotations are provided, so the description carries the full burden. It only says 'Current UTC timestamp' while the input schema exposes nine unrelated parameters with descriptions referencing Git refs, URL normalization, weather hints, JSON validation, and search length checks. This creates confusion about whether the tool performs those checks or simply ignores the parameters, and no output format is disclosed.

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 itself is a single concise sentence, but it is too sparse for the confusing parameter list that follows. It is not front-loaded with the essential fact that the tool requires no parameters and that all given parameters are likely ignored.

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

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

Given the simple nature of the tool, the description omits critical context: whether all parameters are optional/ignored, what the return value looks like, and why the seemingly unrelated parameters exist. The absence of an output schema and the contradictory parameter descriptions make the tool incomplete and practically unusable.

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

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

Although the schema has 100% parameter description coverage, all descriptions appear irrelevant to a UTC timestamp tool. Parameters like 'Git ref name', 'HTTPS URL to normalize or cite', and 'City name for a public weather hint' do not explain how to call utc-time and instead suggest a different, mixed-purpose tool. This actively harms usability rather than adding meaning.

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 UTC timestamp' is clear about the basic output but does not use an explicit verb phrase and fails to distinguish this from sibling tools like 'timezone' or 'iana-zones'. It gives the core purpose but omits any scope or 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?

There is no guidance on when to use this tool versus alternatives such as 'timezone' or 'iana-zones'. The description does not mention the fact that all parameters appear optional and seemingly unrelated, so an agent cannot determine appropriate invocation context.

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

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

With no annotations provided, the description must convey all behavioral details. It only mentions that the body is discarded, but it does not disclose the return value (e.g., boolean, error message), any side effects, or how it handles invalid JSON. This is a significant gap.

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

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

The description is short (two sentences) but poorly structured. It front-loads the purpose, yet the ambiguity of 'body' and the lack of parameter mapping make it ineffective. It could be concise while still being clear, but it is not.

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

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

Given the complexity of the tool (9 parameters, no output schema), the description is highly incomplete. It does not explain what the tool returns, how to handle the optional parameters, or any edge cases. This leaves an agent without essential information to use 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?

The description does not add any meaning beyond the schema. It fails to identify the 'json' parameter as the core input, and it does not clarify the role of the other eight parameters, leaving their purpose entirely to the schema's terse descriptions.

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

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

The description states the tool checks whether a body is valid JSON, but it does not specify which parameter represents the body. Given the schema includes a 'json' parameter, the intent is ambiguous, and the description does not clearly distinguish this tool from other validation tools in the sibling list.

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

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

The description provides no guidance on when to use this tool versus alternatives such as browser-url-ok or file-path-ok. It lacks context about the appropriate scenario or prerequisites (e.g., what constitutes a 'body' or how to supply it).

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 for disclosing behavior, but it does not mention that this performs an external network call to Open-Meteo, whether it is read-only, or how failures and units are handled. Some parameter descriptions hint at non-actions like 'discarded' and 'no disk access', but tool-level behavior remains opaque.

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

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

The description is highly concise with no filler, but it omits critical operational details. It is one short sentence, so it earns credit for brevity, but not for being appropriately complete.

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

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

With 9 optional parameters, no required input, no output schema, and no mention of units, return format, or error handling, the description is far too incomplete for an agent to invoke correctly. The presence of many unrelated parameters further compounds the ambiguity.

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 every parameter has a description, most are unrelated to the weather purpose (e.g., feed, json, path, query) and do not clarify which parameters are actually relevant. The city parameter lacks format guidance, and the schema's optionality leaves ambiguous what input is truly needed.

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

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

The description clearly states the core function: returning the current temperature for a city via Open-Meteo. It names both the resource (temperature) and the external provider, which is enough to distinguish it from sibling tools like web-fetch 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 about when to use this tool versus alternatives, nor are there prerequisites, exclusions, or conditions. The description is only a bare functional statement with no usage 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?

The description discloses one behavioral aspect (body discarded) but omits others like network access, potential side effects, error conditions, or rate limits. With no annotations to supplement, the description carries most of the transparency burden and does not fully address it.

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

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

The description is concise and to the point, using two short sentences. However, it lacks any structural breakdown or explicit guidance, making it slightly less effective than a fully structured description, though still efficient.

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

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

Given the tool's complexity and the schema's many irrelevant parameters, the description does not provide enough context to call the tool correctly. It fails to explain which parameters are actually required, what the response contains, or how it differs from similar tools, leaving the agent without essential guidance.

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

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

The schema contains nine parameters, most of which are irrelevant to an HTTP fetch (e.g., 'city', 'feed', 'zone'). Their descriptions are generic and misleading, such as 'discarded after the shape check', which contradicts the tool's stated purpose. The description text does not clarify that only 'url' is meaningful, so parameter semantics are severely deficient.

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 performs an HTTP fetch and returns status and content type while discarding the body. It is a specific verb+resource and distinguishes itself from siblings like normalize-url or fetch-status by focusing on the response metadata.

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

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

The description offers no guidance on when to use this tool versus alternatives such as fetch-status or browser-url-ok. There is no mention of conditions, limitations, or when not to use it.

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

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

With no annotations, the description carries the burden. It only says 'Title discarded after the call' (implying no state change), but does not mention what is returned, error cases, or side effects. The parameter descriptions also claim values are 'discarded', but the tool's actual behavior is unclear.

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

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

The description is a single sentence, which is concise, but it omits essential information about parameters and return behavior. It is too terse to be useful despite being short.

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 with no enums, no output schema, and no annotations. The description only covers the purpose, ignoring parameter mapping, return type, and error conditions. The mismatch between the description and schema makes it completely incomplete.

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

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

The description mentions a 'title' but none of the 9 parameters are named 'title'. The schema descriptions are generic and unrelated to Wikipedia (e.g., 'Git ref name', 'HTTPS URL to normalize or cite'). The description adds no semantic clarity about which parameter to use or what the others are for.

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

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

The description clearly states the tool checks whether a Wikipedia title exists, which is a specific verb and resource. However, it does not specify what 'exists' means (e.g., redirects, case sensitivity).

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 the many sibling 'ok' and 'shape' tools. More critically, the description mentions 'title' but the 9 parameters in the schema are unrelated (e.g., ref, url, city), so the intended usage is completely opaque.

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