YAML validity, body discarded

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

With no annotations, the description carries the behavioral burden. It discloses that task text is discarded (privacy-relevant) and says it returns connection methods. It does not mention side effects, external calls, rate limits, or errors, so the behavior is only partially transparent.

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

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

The description is exactly two sentences, front loads the purpose, and includes a privacy-relevant behavior without waste. Every phrase earns its place.

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

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

For a 9-parameter, 0-required, no-output-schema tool, the description is reasonably complete: it states what it finds, what it returns, and that task text is discarded. It could clarify how the parameters map to the listed tasks, but the schema already covers each parameter, so the information is not strictly missing.

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

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

The input schema has 100% coverage with descriptions for all 9 parameters, so the baseline is 3. The tool description adds minimal semantic value beyond the schema, mainly the notion of a task text being discarded, which is already reflected in several parameter descriptions. It does not significantly enrich the 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 specific function: 'Find a public pay-per-call tool gateway for a task such as weather, search, scrape, or voice.' It names the resource type (pay-per-call tool gateway), the action (find), and the task categories. This clearly distinguishes it from siblings like weather-hint or web-fetch, which are direct data tools rather than a lookup/gateway finder.

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?

It gives clear task examples (weather, search, scrape, voice) that indicate when to use the tool. However, it does not explicitly mention when not to use it or point to specific alternatives among the many siblings, so it stops short of complete routing guidance.

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 has the full burden of behavioral disclosure. It states that no browser is launched but does not explain what 'can be opened' means (e.g., DNS check, HTTP status check, syntax validation). The schema exposes nine unrelated parameters, many described as 'discarded after the check,' which contradicts the narrow 'URL' focus and is not disclosed. This leaves the tool's actual side effects and scope 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 succinct, consisting of two short sentences with no filler. It front-loads the core purpose ('Check whether a URL can be opened') before the behavior note. Given the tool's surprisingly broad parameter set, the description may be underspecified, but as far as conciseness the text 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?

A nine-parameter tool with no output schema and no annotations requires much more contextual explanation. The description does not state what the tool returns (e.g., a boolean, an error per parameter), how to use the multi-parameter input, or what 'can be opened' practically entails. An agent cannot confidently invoke it for anything beyond the trivial URL-only case.

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

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

Schema description coverage is 100%, so the parameters are already documented in detail. The description itself adds no further parameter semantics. It mentions 'URL' but does not clarify how the other eight parameters relate to the URL check or why they are discarded. Baseline of 3 applies because the schema covers the parameter details.

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

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

The description states a clear verb and resource: 'Check whether a URL can be opened.' It also adds 'No browser is launched,' which helps distinguish it from browser-launch tools like playwright-url-ok. However, it does not explicitly name sibling tools or conditions for choosing this tool over others, so it lacks full 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?

There is no guidance on when to use this tool versus alternatives. The phrase 'No browser is launched' implies a lightweight check, but it never spells out when this tool is preferred, when it is not, or which siblings to choose instead. The agent must infer usage entirely from the name and short 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 provided, so the description carries the entire behavioral burden. It only says 'Expression discarded,' which hints that the input is not store, but it does not explain what the result is, whether the call has side effects, whether it is a read-only check, or what error situations look 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 consists of two short sentences with no fluff and the core 'Evaluate' verb appears first. It earns some credit for being compact, but the terseness contributes to ambiguity and omits operational details the agent needs.

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, so the description must provide strong orientation. It doesn't explain how to express `a+b`, what the evaluation returns, whether the expression is a required runtime concept outside the schema, or how to distinguish this from fetch-status, validate-json, and similar 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?

Although the input schema descriptions cover 100% of the parameters, the tool description adds no mapping between the described 'a+b' expression and any of the nine string fields (ref, url, city, feed, host, etc.). The expression concept has no representative parameter, so the description is off-center with the schema and doesn't help the agent choose which field to populate.

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

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

The description names an operation ('Evaluate a+b style arithmetic') but it is disconnected from the actual input schema, which has no arithmetic expression parameter. 'Expression discarded' further muddles what the tool does, and the description does not differentiate this from sibling validators such as validate-json or yaml-ok.

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

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

There is no guidance on when to use this tool instead of a sibling, and no prompt autofill about when to skip it either. The one-line description never mentions inputs such as query, url, or ref, so an agent cannot decide between calc-eval and closely related validation or normalization 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 carries the full burden and it does add one useful behavioral fact: 'Page content is not stored.' This helps with privacy expectations. However, it does not disclose other behavioral details, such as whether any input is retained, what happens to the non-URL parameters, or what side effects beyond return values exist.

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 with no filler. The primary behavior is front-loaded, and the privacy note is a meaningful addition. Every word earns its place.

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

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

The tool has 9 optional parameters, no output schema, and no annotations, so the description must do more to orient an agent. It explains what is returned but not how to select or prioritize inputs, which parameters are relevant, whether multiple parameters should be provided together, or what happens when they are. An agent would have to rely entirely on the schema to figure out usage.

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 only reinforces that the tool is 'for a URL' but does not clarify the intended relationship among the nine parameters or that most seem to be discarded. It adds little semantic value beyond the schema.

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

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

The description states a specific action ('Return host, scheme, and HTTP status') and a clear target resource ('a URL'), so an agent can tell what the tool fundamentally does. It does not explicitly distinguish this tool from overlapping siblings like fetch-status or normalize-url, so it misses the top tier.

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 alternatives such as fetch-status, normalize-url, or browser-url-ok, and no exclusion criteria. Given the large sibling set, an agent would have to guess which tool is appropriate in a given scenario.

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

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

The description adds one meaningful behavioral detail: 'No identifiers are retained,' which is useful privacy information especially given the discarded claims in the schema. However, it does not disclose any other side effects, return shape, or the practical consequences of classification, so the burden is only partially met given that no annotations are provided.

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, front-loaded, and contains no filler. It uses a short imperative and a single clarifying sentence, which keeps it scannable; however, its sparseness contributes to the ambiguity rather than serving as true concision that solves comprehension.

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

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

For a tool with 9 optional parameters, no output schema, and no annotations, a single cryptic sentence is inadequate. The agent still lacks a clear understanding of how the classification result is returned, how to choose inputs, or how to interpret the compatibility 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%, and each parameter already explains its purpose and discarding behavior. The description adds no additional meaning beyond that general statement, so the baseline 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 says 'Show how this request is classified' but never defines what classification means, what categories exist, or what this tool actually computes. It is vague enough that an agent could confuse it with any of the many sibling classification/validation tools.

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

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

No guidance is given for when to use this tool vs. the 29 alternatives. The description does not mention whether one parameter or multiple should be passed, how to select between ref/url/city/feed/etc., or what the expected output format implies.

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

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

Since no annotations are provided, the description carries the behavioral disclosure burden. It does clearly state that no WHOIS/ownership/network data is involved, which is a useful guarantee. It is brief, but for a pure string-splitting operation that may be enough.

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 dense sentence with the main behavior front-loaded. There is no filler, but it may be slightly too terse because it omits how the input is supplied and whether other parameters are ignored.

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

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

Given a 9-parameter schema with zero required parameters and no output schema, the description does not fully orient the agent. It fails to state that only `host` is relevant, leaving room for misuse with `url`, `json`, or other parameters. For a pure one-input tool, this is a real completeness gap.

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

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

Schema coverage is 100%, so every parameter has a description. The description adds no extra meaning beyond the schema: it says 'hostname' but does not explain parameter selection, format, or how to interpret outputs. Baseline score 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 names a specific action and resource: 'Split a hostname into labels'. It also distinguishes itself from network-heavy siblings by adding 'without WHOIS or ownership data', making it clear this is a local shape operation rather than a lookup/fetch tool. It loses one point because it doesn't explicitly say which schema parameter carries the hostname, though 'host' is inferable.

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 when-to-use or when-not-to-use statement, and no sibling alternative is named. The phrase 'without WHOIS or ownership data' gives implied context that this is for fast hostname-only parsing, but an agent still must infer when to choose this over normalize-url or other shape tools.

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

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

With no annotations, the description must carry behavioral weight. It does convey that the operation is read-only (HEAD over a public URL) and that no content is returned, which is useful. However, it omits details like redirect handling, error behavior, timeouts, or what exactly the returned status 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, front-loaded sentence: 'HEAD a public URL and return status only.' It contains no fluff, no tautology, and every word adds value.

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 with no output schema, and the description gives an agent almost no context to choose the right parameter. The `url` property's schema description says 'HTTPS URL to normalize or cite,' which conflicts with the HEAD behavior described. The description is not sufficient to ensure 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 100%, so structured fields already document each parameter. The description adds no extra parameter-level meaning—it never indicates that `url` is the actual input to use or that the other parameters are irrelevant/ignored. Baseline 3 is correct because the schema carries the information.

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

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

The description clearly states the action (HEAD a public URL) and the result (return status only), which distinguishes it from content-fetching tools like `web-fetch`. However, it does not explicitly differentiate itself from sibling tools, and it leaves 'status' ambiguous—HTTP code vs. plain text—so it is a clear purpose but not fully differentiating.

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 `fetch-status` versus the many sibling tools, nor any direction on which of the 9 optional parameters should be supplied. The description does not say that only `url` is relevant or that the other parameters are discarded, leaving the agent with no selection rule.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says the path is discarded; it does not say whether the tool mutates anything, makes network requests, returns a boolean or parsed object, or fails on invalid input. This is too shallow for a tool embedded in a larger family of validators.

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 short and front-loaded, but it is under-specification rather than disciplined concision. The tool has nine heterogeneous parameters and siblings that overlap with the stated purpose, yet the description only gives one sentence plus a fragment, leaving too much for the agent to infer.

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 not complete enough for the tool's complexity: nine parameters, no output schema, no annotations, and no sibling differentiation. The schema partially compensates by documenting each param, but the description does not connect those params to the core 'Figma file URL' purpose or to the discarded-path behavior in a useful way.

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% parameter description coverage, so the baseline is 3. The description itself adds no real parameter meaning beyond 'Path discarded', which vaguely connects to one of the nine parameters. The schema descriptions already carry the semantics for each field.

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

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

The description names the verb 'Parse' and the resource 'Figma file URL', which is specific enough to separate this from most URL siblings. It also mentions that the path is discarded, so an agent gets one explicit behavioral detail. However, it does not specify what a parsed result looks like, leaving the purpose slightly incomplete.

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 when-to-use guidance, no alternative routing, and no distinction from sibling tools such as normalize-url, browser-url-ok, or the other *-shape tools. There are no exclusion criteria or hints about which tool is appropriate instead of this one.

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 transparency burden. It does disclose one meaningful behavioral trait: no disk access. However, it does not explain what counts as 'safe,' what the tool returns, or how the other eight schema parameters are handled beyond the terse schema descriptions.

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 and front-loaded: two short sentences, no filler, and the most safety-relevant behavioral trait comes second. It earns its place completely.

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. The description explains neither the return contract nor how to decide which of the eight non-path described parameters are relevant. The schema descriptions help, but the overall tool context is under-specified for reliable agent invocation.

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

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

Schema description coverage is 100%, so the baseline parameter semantics burden is low. The description does not add much beyond the schema—it mirrors the path parameter's 'no disk access' note—but it does reinforce that path is the central input. That is adequate, not exceptional.

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 verb and resource: 'Check whether a path looks safe.' It also adds the useful qualifier 'No disk access,' which distinguishes it from filesystem-touching tools. However, it does not define what 'safe' means (syntax, traversal, absolute vs relative), so it stops short of a fully specified purpose.

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

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

There is no guidance on when to use this tool instead of sibling validators such as browser-url-ok or domain-shape, nor any when-not-to-use instructions. The 'No disk access' hint implicitly suggests a safe static check, but no explicit usage context is provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the external service Open-Meteo, giving some context, but does not disclose network call implications, error handling, rate limits, or what params are actually used. It also does not clarify the meaning of 'discarded' in the schema, leaving behavioral expectations vague.

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

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

The description is a single concise sentence that front-loads the core function. It is efficient with no extraneous words; the lack of detail is more about completeness than readability. As a concise sentence, it succeeds, so a slightly above-the-median score is appropriate.

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 too thin to guide correct invocation. It does not identify the required or primary parameter (e.g., city), explain the return format, or note possible failure cases. The tool's behavior is insufficiently specified for an agent to use confidently.

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 itself adds no parameter-level insight, such as which of the 9 optional parameters corresponds to 'a place.' While the schema describes each parameter, it does not explain how to select among them for this tool. Still, the schema fully documents parameters, so the baseline applies.

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

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

The description states the tool returns latitude and longitude for a place via Open-Meteo, which is a clear verb and resource. However, it does not specify which input parameter identifies the place, and the schema lists nine optional parameters without distinction. This leaves ambiguity about how the tool should be invoked, especially among siblings like weather-hint and 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?

The description provides no usage guidance or comparison with alternatives. It does not state when to use this tool versus weather-hint, timezone, or other location-related tools, nor does it exclude any scenarios. The agent is left to infer the appropriate invocation conditions from the schema 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 carries the full burden of behavioral disclosure. It reveals the parse operation but does not state how invalid URLs are handled, what is returned, whether any side effects occur, or any constraints such as input normalization expectations.

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 filler or repetitive content. The central purpose appears immediately and the sentence earns its place.

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

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

The tool has nine optional parameters, no required fields, no output schema, and no annotations, yet the description does not say which parameter drives the parse, what the output shape is, or how the tool behaves on invalid input. It is too thin to fully ground an autonomous agent's invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds a useful hint that the URL is meant to be a GitHub URL and that the tool's purpose is extracting owner and repo, but it does not map these concepts to specific parameters or clarify the purpose of the many other optional 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 names a specific operation ('parse') and resource ('owner and repo' from a GitHub URL), so the intent is clear. It does not explicitly distinguish itself from sibling tools like normalize-url or figma-url-shape, but the GitHub-specific wording makes the target fairly unambiguous.

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

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

There is no guidance on when to use this tool versus alternative URL tools such as normalize-url or domain-shape, and no exclusions or prerequisites. The description simply states the action without contextual routing.

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

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

There are no annotations, so the description must carry the behavioral burden. It does disclose that the count is for the current front page and that titles are discarded, which hints at a read-only, count-only mode. It does not disclose error behavior, external-network assumptions, or whether optional inputs 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?

Two short sentences, each earning its place: the first says what the tool does, the second states an important negative behavior. There is no filler or repetition of the schema.

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

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

For a simple count tool, the description is serviceable: an agent can safely call it with no parameters and expect a count. However, the lack of an output schema and annotations leaves the return format and the effect of the optional generic parameters barely inferred rather than explicitly clear.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the tool description adds little parameter-specific guidance. The nine optional parameters are all documented in the schema, but the description does not clarify how they relate to counting Hacker News stories; 'titles discarded' is the only link to behavior.

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

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

The description clearly names a specific action and resource: count current Hacker News front-page stories. It also adds a differentiating behavior by saying titles are discarded. It does not explicitly name sibling tools or contrast with them, so it just misses the bar for 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?

The phrase 'titles discarded' implicitly tells the agent this is for count-only results, not for retrieving story content. However, it does not explicitly say when to prefer this over, for example, web-fetch, or provide any when-not/alternative guidance.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It reveals nothing: no side effects, no validation actions, no mention of return values or mutation, and does not even confirm whether it reads data or performs an operation. The noun-phrase style gives zero behavioral information.

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

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

The description is extremely short, but that is under-specification, not conciseness. It contains only a noun phrase and lacks the actionable content a tool definition requires to be useful.

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

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

This tool has 9 optional parameters, no output schema, and no annotations, yet the description provides almost no operational context. An agent cannot infer purpose, return format, call rationale, or side effects from this definition; it is severely incomplete.

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

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

Schema description coverage is 100%, so each parameter is individually described in the schema. However, the tool description adds no meaning and many parameters seem unrelated to timezone names (ref, url, city, feed, host, json, path, query). The description does not connect any parameter to the stated purpose, leaving the schema as the only semantic source.

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

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

The description 'Common IANA timezone names for clock calls.' is a noun phrase that does not state an action or operation. It does not mention whether the tool lists, returns, validates, or resolves zones, and it does nothing to distinguish iana-zones from sibling tools like 'timezone' or 'utc-time'.

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 related sibling tools. No conditions, examples, or alternatives are given, and the phrase 'for clock calls' is too vague to inform 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?

There are no annotations, so the description carries the burden of disclosing behavior. It states that the tool fetches a public robots.txt and returns only group counts, which covers the core read-only network behavior. It does not disclose failure modes, whether full content is discarded, or any rate-limit/auth considerations, but it is minimally transparent for a simple public fetch operation.

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

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

The description is a single, front-loaded sentence that is compact and free of filler. It communicates the core action and the output limitation in minimal words, earning high marks for conciseness without losing meaning.

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

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

The tool has 9 optional parameters, no output schema, and no annotations, yet the description does not explain which parameter to use, what shape the input should take, or what the group-count return means. An agent is left to guess between url, host, and others. The description is too lean for this level of ambiguity and provides insufficient context for a reliable call.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add meaning beyond the schema, and notably it does not clarify which of the nine optional parameters supplies the robots.txt URL or hostname. Still, the schema already describes each parameter individually; no contradiction or lost meaning attributable to the 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 states a specific verb and resource: 'Fetch a public robots.txt' and restricts the result to 'group counts only.' This makes the purpose clear and differentiates it from sibling fetch tools like web-fetch, which would return full content. However, it does not explicitly name a sibling or contrast itself in the description, so it stops short of the strongest clarity level.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives such as web-fetch, fetch-status, or normalize-url. It only implies the use case through 'group counts only,' but provides no exclusions or routing hints. An agent gets no context on when 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 provided, the phrase 'Key discarded' is a useful disclosure that the key/input is not retained, which adds some behavioral context. However, it does not cover output behavior, failure cases, or whether any external resources are contacted, so 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 only two sentences, with the purpose front-loaded in the first sentence. The second sentence contributes a distinct meaningful detail about discarding the key, so there is no wasted content.

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

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

This tool has 9 optional parameters, no annotations, and no output schema, so the description needs to explain which parameter should be used as the Jira key and what the check returns. It does neither, leaving an unresolved gap between the described Jira-key purpose and the unrelated parameter list.

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 property has its own description, so the baseline is 3 even though the prose adds little parameter-level detail. The description's 'key' is not explicitly mapped to any of the schema's nine properties, so it does not add beyond what the schema already provides.

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

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

The description states a specific verb and resource: 'Check a Jira issue key shape', and the 'Jira' scoping separates it from sibling shape tools such as domain-shape or github-repo-shape. It is not a tautology, but it leaves the exact meaning of 'shape' and the expected result unstated.

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 prerequisite information, and no explicit when-not or exclusion criteria. The description implies a use case only through the tool name and the word 'Jira'.

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 transparency burden. It clearly discloses that the body is discarded and implies a network status check, but it does not mention redirects, timeouts, or error semantics. The disclosure adds some value beyond the 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 short sentences with no filler, and the key 'Body discarded' behavior is front-loaded as the second sentence. It is highly concise while still conveying an important limitation.

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

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

The tool has nine optional parameters and no output schema, yet the description only explains a single narrow scenario. It does not clarify how to invoke the tool or which field should be populated, making it incomplete for a parameter-rich 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 does not clarify which of the nine optional parameters corresponds to the 'public library docs URL' or whether the parameters are mutually exclusive alternatives. The schema itself provides all the meaningful parameter 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 a concrete outcome ('HTTP status') and a target resource type ('public library docs URL'), and notes the body is discarded. However, it does not distinguish this from sibling URL-checking tools, and 'public library docs URL' is ambiguous.

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

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

There is no guidance on when to use this tool versus alternatives or how to choose among the nine optional parameters. 'Body discarded' is a behavior note rather than an explicit usage condition, so the agent must infer when this is the appropriate helper.

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 side effects and behavior. It does say values are discarded, which is useful, but it does not state whether the operation is purely read-only, what happens for invalid JSON, or what output the caller should expect. For a tool with no annotations and no output schema, this is minimal disclosure.

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

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

The description is two short sentences, directly states the main behavior first, and contains no filler or redundancy. Every word earns its place.

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

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

A 9-parameter tool with no required parameters, no output schema, and no annotations needs much more context than 'Count keys in a JSON object.' The description does not explain which parameter to supply, what the result format is, or what happens for edge cases such as missing JSON or invalid 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 the parameter descriptions themselves are documented. However, the tool description does not map the 'JSON object' to the json parameter, and with 9 optional unrelated parameters the agent must infer which to pass. The schema helps, but the description adds little semantic guidance beyond it.

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

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

The description says exactly what the tool does: count keys in a JSON object and discard values. This is a specific verb and resource, and it distinguishes the tool from siblings like validate-json or yaml-ok. What it does not do is identify which of the 9 input fields supplies the JSON object.

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

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

There is no when-to-use guidance, no exclusions, and no mention of alternatives. The description does not say whether this should be used over validate-json, yaml-ok, or other shape-checking siblings, leaving the agent to infer the appropriate selection 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 full behavioral burden. It does disclose a meaningful behavior: query and fragment are dropped. But it does not mention how invalid URLs are handled, what exactly is meant by 'normalize', or whether there are any other side effects. The disclosure is minimal but present.

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

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

The description is exceptionally concise: two short sentences. The first sentence clearly states the purpose and outputs, and the second adds a key behavioral nuance. No redundant or filler information exists.

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, 0 required, no output schema, and no annotations. The description is sparse and does not explain which parameter to use, how the result is structured (e.g., a single string or an object with origin/host/path), or how the agent should decide between this and the many sibling tools. The description is insufficient for the complexity of the input surface.

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

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

Schema coverage is 100% (all 9 parameters have descriptions). The tool description itself adds no parameter semantic beyond what is in the schema, and the schema already clearly describes the 'url' parameter as the URL to normalize. 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 the core action: 'Return origin, host, and path for a URL' and a clarifying behavioral detail ('Query and fragment are dropped'). This is clear and specific. However, it does not explicitly differentiate the tool from sibling tools like browser-url-shape or github-repo-shape, so it falls just short of a perfect clarity 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?

No guidance is given about when to use this tool versus any of the many URL-related sibling tools. There's no mention of alternatives, prerequisites, or cases where this should be avoided. The description simply states what it does, leaving it to the agent to infer the use case.

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

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

No annotations are provided, so the description bears the full burden of behavior disclosure. It adds one useful fact ('No browser is launched') but ignores whether the tool makes network calls, performs side-effects, or has privacy/rate-limit implications. The open behavior and result semantics are unstated, so coverage is thin.

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

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

One concise sentence with two clauses, both of which earn their place: it states the core function and immediately clarifies a likely false assumption about browser launch. No wasted words, front-loaded with the action.

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, many seemingly unrelated to a URL check (city, json, path, zone, query), yet the description does not explain whether they are alternative inputs or just ignored. With no output schema and no annotations, an agent lacks enough context to know which parameters to supply and what result to expect. The description is too sparse for the schema's complexity.

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

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

Schema coverage is 100%; each parameter has a clear schema description (e.g., 'discarded after the shape check,' 'no disk access'). The description itself contributes no semantic value beyond the schema, so the baseline 3 applies. It does not mislead, but also does not add 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 ('Check') and resource ('whether a URL can be opened'), immediately clarifying the core function. It is somewhat distinct from the name 'playwright-url-ok', but it does not differentiate this from sibling tools like 'browser-url-ok' or 'normalize-url', so it misses the top mark.

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 siblings such as 'browser-url-ok' or 'fetch-status'. The only hint is 'No browser is launched,' which implicitly excludes browser-dependent checks but offers no explicit alternatives or conditions. An agent cannot determine which tool to pick based on 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 must carry the full burden. The phrase 'Query discarded' does disclose a relevant behavioral trait, namely that the query is not retained after the call. However, it does not disclose whether all other supplied parameters are ignored, what the tool returns, or how it behaves when no query is provided, leaving meaningful gaps.

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

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

The description is short and front-loaded. Both sentences contribute value, and there is no filler or redundant preamble. A score of 5 is not warranted only because the brevity also hides important operational details that the description would still need for a fully self-sufficient definition.

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

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

Given zero annotations, no output schema, and nine optional parameters with no explicit dependencies, this description is too thin to be fully actionable. It does not state that only `query` is used, what return type or shape to expect, or what happens when `query` is omitted, so a first-time agent cannot confidently plan the call.

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, so the rubric baseline is 3. The tool description itself does add a small signal that `query` is the meaningful input, but it does not clarify that the other eight optional parameters are likely irrelevant, nor does it explain the ambiguity created by having zero required parameters.

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

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

The description clearly states a verb and resource: count characters in a search query. It is easy to tell apart from sibling tools like validate-json or wiki-title-ok, but it does not explicitly disambiguate itself from other single-purpose counter/validators.

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

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

No guidance is given for when to choose this tool over siblings. There is no mention of when not to use it, what alternatives exist, or how to conditionally select it. The one-line description implies a narrow use case but does not help an agent decide between this and other check/count 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 carries the full burden of behavioral disclosure. It says nothing about read-only vs. mutating, return format, side effects, or whether parameters are ignored or used materially. The word 'catalog' might imply a read-only lookup, but that is an inference, not a disclosure.

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

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

The description is a single short sentence, but it also is severely under-specified for a tool with 9 parameters. It is not conciseness; it is an absence of information. There is no front-loading of critical information, because nothing beyond a vague noun phrase is provided.

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

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

Given the tool has 9 parameters, no output schema, and no annotations, this description is wholly incomplete. It cannot tell the agent what to send, what to expect back, or why this tool exists alongside 30+ siblings. The description offers essentially no context, so an agent would be unable to use this tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself adds no additional meaning to the parameters; it does not explain how the 9 disparate parameters (city, host, json, zone, path) relate to a status code catalog. Still, because the schema fully describes each parameter, the description is not required to repeat those details. The mismatch between the stated purpose and the parameter list remains a gap, but the schema fills the immediate semantic need.

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 phrase 'Short catalog of common HTTP status codes' identifies the resource (HTTP status codes) and implies a noun-based catalog, but no verb or action is specified. It does not distinguish itself from siblings like 'fetch-status' or 'browser-url-ok', which could also involve status codes. The purpose remains ambiguous: is it a static reference list, or does it use the 9 parameters to filter/lookup?

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 zero guidance on when to use this tool versus the many sibling tools. No context is provided for what kind of task should route the agent here, and no exclusions point to a more appropriate tool. The description does not explain whether it is intended for spot-checking a URL status, listing all codes, or something else.

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

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

With no annotations, the description carries the behavioral disclosure burden. It clearly states that the prompt is discarded, which is an important behavioral fact. However, it does not describe side effects, storage, or whether all provided 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 and front-loads the primary purpose. The second clause adds an important behavioral warning without unnecessary 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?

Despite having no annotations and no output schema, the description does not discuss why the tool accepts nine varied parameters, what a caller should or should not provide, or how this tool fits among its siblings. An agent is likely to send an unnecessary argument or call another 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 input schema already documents each parameter. The tool description adds 'Prompt discarded' but does not explain how the nine declared parameters relate to that behavior, leaving the baseline score at 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?

The description states a specific action and output: 'Return a three-step thinking template.' This is clear enough to identify the tool's core purpose, though it does not explicitly distinguish it from sibling tools.

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

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

No explicit guidance is given for when to use this tool or when to prefer a sibling tool. 'Prompt discarded' hints that the input prompt will not be processed, but it does not explain whether callers should omit arguments or how this compares to alternatives.

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

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

No annotations are provided, so the description carries the behavioral burden. It conveys that the tool is a read-only time lookup, but it does not mention invalid timezone behavior, output format, or whether any fallback is used. This is acceptable but leaves important behavior unspecified.

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 filler. It is front-loaded with the action and resource and earns its place.

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

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

The description is complete enough for basic selection, but with nine optional parameters and no output schema, it does not explain invocation details such as whether `zone` is required or what the returned time value looks like. The schema partially compensates, but some practical context is missing.

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

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

Schema description coverage is 100%, so the parameters are already documented individually. The tool description adds only the 'IANA timezone' semantic and does not clarify which of the nine optional parameters is actually needed to invoke the tool correctly.

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

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

The description clearly states the tool's purpose: returning the current time for a named IANA timezone. It is specific about the resource and action, but it does not explicitly differentiate itself from siblings such as `iana-zones` or `utc-time`.

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

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

The description implies when to use the tool—when a current wall-clock time in an IANA timezone is needed—but it provides no explicit when-not-to-use guidance or references to alternatives. It leaves the agent to infer the boundary 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?

With no annotations, the description must carry the behavioral burden, but it only states the output. It does not disclose that the optional parameters are discarded, that the call has no side effects, or what format the timestamp takes. The schema parameter descriptions hint at discarding, but the tool description itself omits these behavioral 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?

One sentence is concise and front-loaded, but it is under-specified for a tool with 9 optional parameters and no output schema. Brevity here comes at the cost of necessary nuance rather than trimming filler.

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

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

The tool has no output schema, no annotations, and 9 optional parameters, yet the description provides only a one-phrase output statement. An agent cannot tell the timestamp format, whether parameters are ignored, or how to relate the parameters to the output, making the description incomplete for correct invocation and understanding.

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 optional parameter has descriptive comments like 'discarded after the shape check' or 'no disk access', so the schema carries most parameter meaning. The description adds no clarity about why a UTC timestamp tool takes URL, city, JSON, and path params or whether they are all ignored.

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' clearly identifies the returned resource and distinguishes it from datetime-helpers such as timezone or iana-zones. However, it does not explain how the 9 optional parameters relate to the purpose or differentiate it explicitly from sibling tools.

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

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

There is no guidance on when to call this tool versus alternatives like timezone or other validation tools. The description says nothing about whether parameters are optional, irrelevant, or when to omit them, leaving the agent with no usage direction for a tool that accepts 9 unrelated-looking optional parameters.

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 transparency burden. It discloses the core behavior: the input body is checked for valid JSON and then discarded, indicating a read-only, no-side-effect operation. However, it does not state what is returned on valid/invalid input, whether an error is thrown, or how additional non-json parameters (9 in schema) 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 just two sentences with zero filler. It front-loads the purpose action and then adds the discarding behavior as a separate short sentence. Very efficient and tightly structured.

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

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

The tool has 9 parameters, no output schema, and no annotations. The description leaves out what the return value looks like (boolean? status?), how invalid JSON is surfaced, and why the other eight parameters exist if they don't affect the validation. The missing overhead for a non-trivial schema makes it 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 description coverage is 100%, so the input schema already documents each parameter. The description adds no further parameter-specific meaning; the only temporal statement is about 'body' being discarded, which offers some context but does not map to a particular parameter. The baseline of 3 is appropriate.

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

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

The description states a specific action: 'Check whether a body is valid JSON.' This clearly distinguishes it from sibling tools like yaml-ok (YAML validation) or file-path-ok (path shape). The word 'body' is ambiguous but likely refers to the 'json' parameter; the tool name itself clarifies the 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 given about when to use this tool instead of other sibling validation tools. It does not say 'for JSON use validate-json, for YAML see yaml-ok'. There are no when-not-to-use or alternative conditions, leaving the agent to infer which is the right validator.

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

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

There are no annotations, so the description carries the full behavioral burden. 'Current temperature for a city via Open-Meteo' suggests a read-only external lookup, but it does not disclose error behavior on unknown cities, network dependency, response content, or whether the temperature returned has any unit/format guarantees. This is a meaningful transparency gap.

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

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

The description is one short, front-loaded sentence with no filler. Every word contributes to identifying what the tool does and the data source.

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, and no output schema, a one-sentence description is not enough. The agent is left without clarity on what the function returns, what happens when extraneous inputs are supplied, how the tool handles missing optional parameters, or what constraints apply to successful invocation.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the tool description itself only mentions the city concept. The full 9-parameter schema is self-documenting, but the description does not explain why the other optional parameters exist or which are relevant to a weather lookup.

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

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

The description clearly identifies the tool as returning current temperature for a city through Open-Meteo. It is distinct enough from siblings such as geo-hint and timezone to discriminate, though it lacks an explicit verb such as 'fetches' or 'returns'.

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 the tool should be used when a caller wants current weather for a city, but it gives no guidance about when not to use it or how it relates to alternatives like web-fetch, geo-hint, or browser-url-ok. No if/then or when-to-use/when-not-to-use guidance is present.

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 behavioral burden. It does disclose that the body is discarded, which is helpful, but it does not describe timeouts, redirects, error behavior, or the fact that making a request may reveal the URL to an external service.

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, front-loaded sentences with no fluff. It states the important output first and then the key limitation, which makes it easy to grep and 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?

The tool has nine optional parameters, no output schema, and no annotations, but the description is sparse. It does not explain how to select the right parameter, whether the other fields are decoys, or what the response looks like beyond 'status and content type,' leaving meaningful 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?

Schema description coverage is 100%, so the baseline is 3. The description only adds that a public URL is involved, but it does not clarify which parameter is the actual fetch target or why the remaining parameters exist beyond their individual schema 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 clearly says the tool exposes HTTP status and content type for a public URL and that the body is discarded, so the core purpose is unambiguous. It does not, however, distinguish it from overlapping siblings such as fetch-status or browser-url-ok.

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

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

The phrase 'for a public URL' and 'body discarded' gives a useful hint that this is for lightweight URL checks, implying when it should be used. It does not explicitly compare to alternatives or explain which of the nine parameters is the relevant one, limiting its selection guidance.

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 includes one behavioral detail: 'Title discarded after the call,' which discloses transient data handling. However, with no annotations provided, the description carries the full burden of behavioral disclosure and does not state whether the operation is read-only, whether it makes network requests, how exactness/casing is handled, or what the result 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 only two short sentences and front-loads the core verb and resource. There is no unnecessary wording or padding, so conciseness is good even if the second sentence adds marginal value.

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 and heterogeneous parameters, no output schema, and no annotations, this description is far too incomplete. An agent cannot determine which parameter supplies the title, what response to expect, or what 'exists' means with respect to Wikipedia—whether an exact article title, a redirected page, a URL, or something else.

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 high, so it is a baseline of 3 if the description merely does not add parameter detail. But here none of the 9 schema properties (ref, url, city, feed, host, json, path, zone, query) is described as the Wikipedia title, and the tool description offers no mapping. This makes the parameter side actively confusing rather than merely unhelpful.

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 says the tool checks whether a Wikipedia title exists, which is a specific verb and resource. It also distinguishes it from sibling validators like browser-url-ok or github-repo-shape by naming Wikipedia-title existence. However, the input schema exposes no `title` parameter, so the stated purpose is not actually mapped to a callable argument.

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 choose this tool over siblings such as browser-url-ok, web-fetch, or fetch-status. The description does not mention which input format is expected, when the check is appropriate, or what alternatives exist.

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 offers one useful cue—that the body is discarded—but says nothing about side effects, permission needs, error behavior, or what prompts were falsely returned for invalid input, all of which matter for a tool with no annotation safety profile.

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

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

The description is short but under-specified: a single noun phrase does not meaningfully convey capability. This is not economical precision but omission of essential content, especially for a tool with 9 optional parameters and no output schema.

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

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

The tool has 9 parameters, no annotations, no output schema, and 28 siblings, yet the description in no way helps an agent understand when or how to invoke the call. The mismatch between the YAML-focused description and the schema's broader validation fields further confuses the context, making the definition inadequate 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 100%, so the baseline is 3. Each parameter already has a written description in the schema, but the tool description contributes no extra semantic, and the YAML-focused description does not reconcile with the schema's json field or other unrelated 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 'YAML validity, body discarded' is a terse noun phrase that mostly restates the tool name 'yaml-ok' rather than stating a clear capability. It does not use a verb indicating what the tool does, and the input schema's nine fields (ref, city, zone, etc.) appear largely unrelated to YAML, making the intended 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?

There is no guidance about when to use this tool versus any of the 28 siblings. The description does not mention context, prerequisites, alternatives, or exclusions, leaving an agent to guess which validator or shape-check tool fits the task.

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