ISO country KI

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

No annotations are provided, so the description carries the behavioral disclosure burden. It does disclose the read-only nature of 'Find', the public access, the 'pay-per-call' cost implication, the fact that 'Task text discarded', and the expected return artifacts. However, it does not mention rate limits, authentication needs, or whether the tool makes external network calls beyond the 'remote MCP hops' hint, so some important behavioral context is missing.

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

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

The description is two sentences and front-loads the main action and outputs. There is no filler or redundant restating of the tool name. The only minor inefficiency is that 'public pay-per-call tool gateway (Monid)' could be tightened, but the overall structure is compact and scannable.

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 gives the purpose, the return artifacts, and the important disposal of task text, which covers the core call semantics. However, given 9 mostly dummy parameters, no required parameters, no annotations, and no output schema, it would be more complete if it explicitly stated that the parameters do not affect the returned content beyond validation. That would prevent an agent from expecting the tool to actually process a URL, city, query, or JSON payload.

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

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

Schema description coverage is 100%, with each of the 9 parameters already described as either discarded, checked, or not accessing disk. The description adds no parameter-level meaning beyond the schema. Baseline 3 is appropriate because the schema already handles the semantic burden for each parameter.

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

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

The description opens with a specific verb and resource: 'Find a public pay-per-call tool gateway (Monid)', and it lists concrete outputs: CLI setup, how-it-works, skill file, and remote MCP hops. This is not a tautology and gives an agent a clear sense of the tool's function. It is not explicitly contrasted with siblings, but the Monid-specific scope sets it apart from the generic URL/validation helpers.

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 guidance, and no alternative tools are named. The only usage signal is the implied condition that a Monid gateway is being sought, which is weak among 27 siblings. An agent would have to infer when this tool is appropriate instead of being told.

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

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

With no annotations, the description carries the full burden of explaining behavior, but it only states that no browser is launched. It does not mention network requests, output format, error behavior, or side effects, leaving the actual behavior largely ambiguous.

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 appropriately short and front-loaded, with the core purpose stated first. The negation 'No browser is launched' is concise and useful, though the overall tool description could benefit from a brief mention of the output.

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

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

Given nine parameters, no output schema, and no annotation context, this description is far too incomplete. It does not explain what the tool returns, how the parameters relate to the check, or what 'can be opened' means in terms of HTTP status or network behavior.

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

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

Although the schema has 100% description coverage, the parameter descriptions are largely irrelevant or misleading for a URL-open check. Terms like 'Git ref name; discarded after the shape check' or 'City name for a public weather hint; discarded after the call' do not add meaningful semantics and appear to be copied from unrelated tools.

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 ('Check') and the resource ('whether a URL can be opened'), giving a solid basic purpose. However, it does not distinguish this tool from sibling tools like playwright-url-ok, fetch-status, or normalize-url, so it misses the highest level of clarity.

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

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

There is no guidance about when to use this tool versus alternatives. The brief note 'No browser is launched' hints at a lightweight check, but it never explicitly says when this tool is preferred or avoided.

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 explaining side effects, persistence, errors, and return behavior. It only vaguely says the expression is discarded, and the schema parameter descriptions contradict the arithmetic purpose by referencing unrelated 'shape checks' and discarded values.

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, which is efficient, but it omits the most essential information about how to provide the expression. Being brief at the cost of correctness and usefulness is not effective structuring.

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

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

Given 9 parameters, no output schema, and no annotations, the description is far from complete. It fails to explain how the parameters relate to arithmetic evaluation, what the tool returns, or what 'discarded' means for the caller.

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 all 9 parameters have schema descriptions, those descriptions are nonsensical in the context of arithmetic evaluation, e.g. 'Git ref name; discarded after the shape check' and 'JSON text to validate; discarded after the check'. No parameter is described as the expression to evaluate, so the schema adds confusion rather than 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 claims the tool evaluates 'a+b style arithmetic', but the input schema contains no expression parameter; instead it lists unrelated parameters like ref, url, city, and feed. It does not indicate which parameter carries the arithmetic expression, and it fails to distinguish this tool from siblings such as validate-json or normalize-url.

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

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

No guidance is given for when to use this tool, how to structure an arithmetic call, or which parameter is required. The phrase 'Expression discarded' is confusing rather than instructive, and there are no examples or prerequisites.

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

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

With no annotations provided, the description carries the behavioral burden. It does disclose a meaningful behavior: page content is not stored, which suggests a privacy-conscious, lightweight operation. However, it does not clarify whether the tool makes a network request, follows redirects, or has any side effects beyond the stated output, leaving gaps for an agent to reason about.

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

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

Two short sentences with no filler. The primary action and output are front-loaded, and the additional privacy caveat is a valuable second sentence that 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?

Given 9 parameters, no output schema, no annotations, and many overlapping sibling tools, this description is too thin. It does not explain the purpose of the extra parameters, the expected return format, or error behavior, leaving an agent with significant ambiguity about how to invoke the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents all 9 parameters. The description reinforces that 'url' is the key input by tying the output to a URL, but it does not explain how the other optional parameters such as city, zone, or json relate to the citation behavior, nor does it clarify whether they should be 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 clearly states a specific verb ('Return'), resource ('a URL'), and output values ('host, scheme, and HTTP status'). This is more specific than the tool name alone and helps distinguish it from content-fetching siblings like web-fetch, though it does not explicitly differentiate from fetch-status or normalize-url.

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

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

The description gives no explicit when-to-use or when-not-to-use guidance, and it does not mention any alternatives. The phrase 'Page content is not stored' weakly implies this is not for content retrieval, but there is no clear directional signal about when to prefer this over fetch-status, normalize-url, or web-fetch.

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

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

With no annotations, the description must carry the full behavioral burden, but it only states 'No identifiers are retained.' It does not disclose whether any external calls occur, whether the operation is read-only, or what side effects exist. The parameter-level discard notes are in the schema, not this description.

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

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

The description is two short sentences with no filler and the main purpose is front-loaded. It is concise, though the terseness contributes to the overall vagueness.

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 tool with no output schema and no annotations, the description is too thin. It does not explain what a classification looks like, which parameters are relevant, or what the agent should expect in the response. The schema documents each parameter but does not compensate for the missing operational context.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself adds no parameter-level meaning beyond the schema; the per-parameter discard semantics are already fully documented in the input 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 provides a verb ('Show') and a vague object ('how this request is classified'), but it never defines what classification means, what categories are returned, or how it relates to the tool name 'compatibility'. It also does not distinguish this tool from the many sibling check/classification 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 versus alternatives like domain-shape, validate-json, or fetch-status. There are no exclusions, conditions, or mention of the scenarios this tool is designed for.

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

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

With no annotations, the description carries the full burden of explaining behavior. It only states a negative constraint ('without WHOIS or ownership data') and fails to mention what the tool returns, possible side effects, or error conditions. The schema contains unrelated fields (e.g., 'Git ref name', 'City name') that create confusion about actual behavior, reducing transparency.

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

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

The description is a single, concise sentence that avoids unnecessary words. It is easy to read and does not include fluff. However, it could be structured to include more relevant details without becoming verbose, so it does not earn full marks for structure.

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

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

The description is highly inadequate for correct invocation. With 9 optional parameters, none of which are clearly tied to the hostname mentioned in the description, the agent cannot know what inputs to provide or what output to expect. There is no explanation of the tool's behavior beyond the basic split action, making it impossible to use correctly without external knowledge.

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 parameter descriptions in the schema are inconsistent with the tool's stated purpose. For example, 'ref' is described as a Git ref name, and 'city' as a city name, neither of which relate to splitting hostnames. The tool description does not map the hostname input to any of the listed parameters, leaving the agent unable to determine which parameters are relevant or how they should be populated.

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: splitting a hostname into labels, using a specific verb and a clear resource. However, it does not explicitly distinguish itself from sibling tools like normalize-url or web-fetch, though that is not strictly required for purpose clarity.

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

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

The description lacks any guidance on when to use this tool versus alternatives, such as normalize-url or web-fetch. There are no preconditions, typical scenarios, or hints about the context in which the tool should be invoked, leaving the agent without sufficient direction.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It usefully indicates a read-only HEAD request against a public URL with only status returned, but it omits details about redirects, failures, timeouts, or the exact status response format.

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

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

A single front-loaded sentence with no filler. The method, target, and result are immediately clear and scannable.

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 the simple advertised purpose, the schema exposes nine optional parameters and there is no output schema. The description does not clarify which parameter is actually used, what the returned status looks like, or why the other parameters are accepted, leaving an agent to guess the 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. The description adds no parameter-specific guidance, and the `url` schema text ('normalize or cite') is somewhat misaligned with the HEAD behavior, but the schema does document each parameter.

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

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

The description names a specific operation ('HEAD'), a resource ('a public URL'), and the exact output ('status only'), clearly distinguishing it from siblings like web-fetch or browser-url-ok.

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

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

There is no guidance on when to use this tool versus similar siblings such as web-fetch, browser-url-ok, playwright-url-ok, or status-catalog. No conditions, exclusions, or alternatives are mentioned.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only reveals that the path is discarded, and does not mention whether validation occurs, what the output is, or whether any side effects are involved.

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

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

The description is very short, front-loaded, and contains no filler. The fragment 'Path discarded' is economical but somewhat cryptic, which prevents a top score.

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

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

With no output schema, no required parameters, and a large optional schema, this description is not sufficient for reliable invocation. An agent cannot predict return values, validation behavior, or which parameter matters most.

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

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

Schema descriptions cover all parameters, so the baseline is 3. The description loosely associates the Figma URL with the generic `url` parameter and hints that `path` is unused, but it never explicitly names which parameter to populate among the many optional fields.

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 action ('Parse') and target resource ('a Figma file URL'), which differentiates it from generic sibling URL tools like normalize-url and browser-url-ok. 'Path discarded' adds a scoping note, though what parsing actually returns is left unspecified.

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 is for handling Figma file URLs, but it does not explicitly say when to prefer this over sibling URL/shape tools. No alternatives, exclusions, or input conditions are stated.

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

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

With no annotations, the description carries full responsibility for behavior; the 'No disk access' statement is a valuable and explicit side-effect guarantee. But it does not disclose whether the tool returns a boolean, what safety rules are applied, how invalid inputs are handled, or which parameter(s) it checks, leaving significant 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, front-loaded sentence with no wasted words: the core purpose comes first, followed by a useful side-effect qualifier. It is appropriately sized for a simple checker, though it sacrifices detail that is penalized in other dimensions.

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

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

For a tool with 9 optional parameters, no output schema, no annotations, and many sibling validators, this description is too thin. It omits the return value, whether the 'path' parameter is the intended input, what 'safe' covers, and how to distinguish this from similar shape-check tools, so an agent cannot confidently invoke it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3; each parameter already has a clear description, and 'path' directly says 'File path to check.' The description adds no parameter-level meaning and does not disambiguate the several seemingly unrelated optional parameters (ref, city, feed, json, zone, query) present in the schema.

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

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

The description states a specific verb and resource: 'Check whether a path looks safe' and adds a clarifying side-effect constraint, 'No disk access.' It is clearly distinct from sibling URL/domain/title validators by focusing on file paths, although it never defines what 'safe' means or explicitly contrasts with those siblings.

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 'No disk access' implies this is a pure syntactic safety check and should not be used to verify real file existence, which is useful context. However, there are no explicit when/when-not rules or named alternatives, so the agent must infer when to choose this over sibling shape-checkers.

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

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

No annotations are provided and the description does not disclose whether the operation is read-only, makes network calls, or handles errors. The 'discarded after' phrases hint at side-effect-free behavior but are inconsistent and do not form a clear behavioral contract.

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

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

The description is concise and front-loaded, and the schema is cleanly structured. However, the concision comes at the expense of essential information, so it is only average.

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

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

With nine optional parameters, no required fields, no output schema, and no explanation of which input selects the place, the tool cannot be called correctly from the given context. The description leaves too many operational gaps.

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

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

Although every parameter has a schema description, the descriptions are generic and misleading, such as 'city' being for a public weather hint and 'query' being discarded after a length check. The description does not explain how any parameter maps to the place being geocoded.

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

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

The description states that the tool returns latitude and longitude for a place via Open-Meteo, which distinguishes it from weather-hint and timezone tools. However, with nine optional parameters and no indication of which one identifies the place, the purpose is not actionable.

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

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

No guidance is given on when to use this tool versus siblings such as weather-hint or normalize-url. There are no conditions, prerequisites, or examples 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, and the description does not disclose validation behavior, error handling, or why many unrelated parameters exist. The 'discarded' notes in parameter descriptions hint at behavior but are not explained.

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

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

The description is one concise sentence with no unnecessary words or repetition.

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

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

There is no output schema or return format described, no statement that 'url' is required, and no indication that the other eight parameters are likely irrelevant. An agent cannot reliably know how to call this tool and interpret the result.

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

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

Although schema coverage is 100%, most parameter descriptions are generic or unrelated to parsing GitHub URLs. The 'url' description says 'normalize or cite' rather than 'parse owner and repo,' and no required parameters are indicated.

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

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

States a specific verb and resource: 'Parse owner and repo from a GitHub URL.' This is clear enough to distinguish from sibling URL-shape tools, though it does not name them.

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

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

No explicit guidance on when to use this tool versus sibling URL parsers like figma-url-shape or jira-key-shape; the intended usage is only implicit from the description.

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

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

With no annotations, the description carries the behavioral disclosure burden. It adds one useful trait—'Titles discarded'—indicating the output is only a count. It does not mention network dependency, side effects, or return format, so it only partially covers behavioral transparency.

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

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

The description is two short sentences with no filler. The main action is front-loaded and the behavioral clarification is concise and purposeful.

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 conveys the core operation and the fact that titles are not returned. However, with no output schema, it does not state the return type or error/availability behavior, and the 9-parameter generic schema is left unexplained, creating some ambiguity about how to invoke the tool correctly.

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

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

Schema description coverage is 100%, so the baseline applies and each parameter is individually documented in the schema. The description adds no parameter-level meaning; its 'Titles discarded' note is about output, not parameters. Because the schema already handles semantics, a 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 uses a specific verb ('Count') and resource ('current Hacker News front-page stories'), making the tool's function immediately identifiable. The final sentence, 'Titles discarded,' clarifies that it returns a count rather than story titles, which also helps distinguish it from fetch or citation tools.

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

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

The description implies when to use the tool: whenever a current count of Hacker News front-page stories is needed. However, it does not explicitly state when not to use it or name alternatives, leaving usage guidance to inference rather than explicit 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?

No annotations are present, so the description carries the full burden of behavioral disclosure. It does not say whether the tool is read-only, what it returns, or how the many schema parameters are handled. The schema contains odd notes about discarded values, but the description itself leaves the tool's behavior completely opaque.

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

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

The description is short and has no fluff, but it is under-specified rather than genuinely concise. It omits a verb, return behavior, and usage context, so the brevity works against usefulness. A one-line fragment is not adequately sized for a tool with nine optional parameters and no annotations.

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

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

With no output schema, no annotations, and a large sibling list, the description is far from complete. It does not explain what the tool returns, what 'common' means, or how the schema's parameters relate to the tool's purpose. An agent would struggle to infer correct invocation or interpret results.

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

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

The schema has 100% parameter description coverage, so the baseline is 3. However, the description adds no parameter meaning and does not connect the timezone domain to the unrelated-looking parameters like url, json, or path. The schema documents each parameter, but the overall mismatch reduces any additional semantic value.

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

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

The description is a noun phrase with no verb: 'Common IANA timezone names for clock calls.' It does not state whether the tool lists, returns, validates, or provides these names, so an agent cannot tell what action is being performed. It names the domain but does not distinguish from siblings such as 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 versus alternatives. The phrase 'for clock calls' hints at a use case, but no explicit conditions, exclusions, or references to related sibling tools are provided. An agent has no way to decide between iana-zones and timezone or utc-time.

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

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

The description discloses that the operation is a fetch, that the target is public, and that the result is intentionally limited to group counts. However, with no annotations provided, it does not describe error behavior, redirects, or how the robots.txt URL is selected, leaving some behavioral 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 a single, front-loaded sentence with no filler. 'Return group counts only' is a necessary qualifier that usefully bounds the output, and 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 definition is too sparse for reliable invocation given the large set of optional parameters, no annotations, and no output schema. An agent cannot tell which parameter supplies the robots.txt URL or what the returned group counts look like, so the context is 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 baseline is 3 even with no additional parameter information. The description adds no mapping between the robots.txt intent and the many optional parameters—it is unclear whether to pass host or url—so it does not meaningfully compensate for that ambiguity.

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

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

The description states a specific action ('Fetch'), a concrete resource ('a public robots.txt'), and the output scope ('return group counts only'). It is clear and actionable, but it does not explicitly differentiate itself from sibling tools like web-fetch or fetch-status.

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

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

The intended context—fetching a robots.txt file and summarizing its groups—is implied by the description, but there is no explicit statement about when to use this tool versus alternatives. It does not mention exclusions, such as when full content retrieval would be more appropriate.

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

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

The phrase 'Key discarded' hints that the input is not stored or modified, but the description does not explain what shape is validated, what input format is expected, what the result looks like, or what failure conditions may occur.

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

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

The text is very short and front-loaded, but the extreme brevity leaves out essential information about how to supply the key and what the check entails, so the structure is not usefully complete.

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

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

With no output schema and no annotations, the description alone does not provide enough context to know what to pass, what the tool returns, or how to interpret a successful or failed shape 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?

Although the schema has descriptions for every parameter, the descriptions are generic and inconsistent with the tool's stated purpose. For example, 'Git ref name', 'City name', and 'Search text' parameters are all said to be discarded, and no parameter is described as a Jira issue key.

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 verb 'check' and the target 'Jira issue key shape', but it does not indicate which of the nine schema parameters supplies the key, and none of the parameter names (ref, url, city, feed, host, json, path, zone, query) obviously maps to a Jira issue key. This makes the purpose only nominally clear.

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

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

There is no guidance about when to call this tool, how to choose among the many input parameters, or how it compares to sibling shape/validation tools such as github-repo-shape or domain-shape.

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

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

The description discloses one meaningful behavior: the response body is discarded, so only the HTTP status is relevant. With no annotations provided, it does not go far enough to explain network behavior such as whether redirects are followed, timeouts, failure responses, or whether any validation is performed beyond the URL itself.

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

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

The description is extremely short and front-loaded: 'HTTP status for a public library docs URL' states the primary function, and 'Body discarded' adds a key detail in a compact sentence. It is efficient with no filler, though the brevity leaves some contextual gaps.

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

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

With nine optional parameters, no required parameters, no output schema, and no annotations, the description is too minimal for an agent to understand which parameter or combination of parameters to pass and how the tool behaves across different inputs. The schema explains individual parameters, but the description does not clarify how they relate to the stated purpose or what the HTTP status response looks like.

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 coverage, with each of the nine optional parameters having its own description, so the schema already carries most of the semantic weight. The tool description adds no parameter-specific meaning and even creates mild ambiguity by describing a 'docs URL' while the url parameter is described as 'HTTPS URL to normalize or cite'.

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

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

The description clearly states that the tool returns an HTTP status for a docs URL and that the body is discarded, which identifies the core operation. However, it does not differentiate this from sibling URL-status tools such as fetch-status, browser-url-ok, or playwright-url-ok, and the phrase 'public library docs URL' is narrower than what the schema parameters imply.

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

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

There is no guidance on when to use this tool versus alternatives like fetch-status, browser-url-ok, or playwright-url-ok. The description gives no context for choosing this tool, no exclusions, and no mention of what makes lib-docs-hint preferable for a given situation.

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 behavioral burden. It does disclose one meaningful trait: values are discarded, so the count is independent of value content. However, it does not state whether nested keys are counted, what happens with invalid JSON, or what the output shape is.

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

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

The description is extremely concise and front-loaded, with no wasted words. It is slightly too sparse for a tool with nine optional parameters and no title, but it avoids fluff and each 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?

For a tool with no annotations, no output schema, and nine optional parameters, this description is incomplete. It does not say which parameter should contain the JSON, what value is returned, how nesting is handled, or how it differs from validate-json. The 'Values discarded' sentence is helpful but insufficient.

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

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

Schema description coverage is 100%, so the baseline is 3. The description clarifies that the operation is counting rather than validating, but it does not explicitly map 'JSON object' to the 'json' parameter. The schema's own description of 'json' as 'JSON text to validate' adds confusion rather than connecting it to key counting.

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 uses a specific verb ('Count') and resource ('keys in a JSON object'), and 'Values discarded' further clarifies the operation. It is clear enough to be distinguished from siblings like validate-json by intent, but it does not explicitly name alternatives or describe its exact input parameter.

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 validate-json or other sibling tools, no stated use cases, and no exclusions. An agent must infer applicability solely from the purpose phrase.

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

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

With no annotations, the description must carry the behavioral burden. It does disclose a key transformation (query and fragment are dropped) and implies a read-only extraction by saying 'Return'. It does not mention invalid URL handling, error cases, or whether any network access occurs, but for a simple normalizer this is partial rather than absent.

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

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

Two short sentences with no filler. The main output is front-loaded, and the additional behavioral note 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 absence of annotations and output schema, combined with a large set of mostly irrelevant optional parameters and no sibling differentiation, leaves the agent without enough context to know the return structure or to be certain only `url` matters. The core idea is present, but the surrounding context is not adequately resolved.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-specific details, but the schema already identifies `url` as the URL to normalize and marks the other parameters as discarded. The overlap between output names and input names (`host`, `path`) is mildly confusing but not actively misleading.

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

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

The description states a specific operation: return origin, host, and path for a URL, and it adds a concrete behavioral detail about dropping query and fragment. This is clear and not a tautology, but it does not explicitly contrast with URL-related siblings like web-fetch or browser-url-ok, so it stops short of full 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 instead of the many URL-related siblings, no exclusions, and no prerequisites. The intended use is only implied by the tool name and the output 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 bears the full burden of behavioral disclosure. It reveals one useful trait (no browser is launched), but it does not state whether a network request happens, whether the operation is read-only, what the return value looks like, or that most inputs are discarded.

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 two sentences are short and front-loaded, but this is under-specification rather than concise completeness for a nine-parameter tool. The description omits the tool's multi-input nature and its output, so the brevity does not serve the agent's decision-making.

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

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

With no annotations, no output schema, and nine heterogeneous parameters, the description must explain overall behavior, return semantics, and parameter selection, but it only addresses URL checking. The description is inadequate for an agent to call this tool correctly for non-URL inputs.

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

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

Schema description coverage is 100%, so each parameter has a meaningful description and the baseline is 3. The tool description itself adds no parameter-level detail, and its narrow focus on URL actually obscures the other eight accepted input types, but it does not misdescribe any specific parameter.

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

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

The description states a specific action ('Check whether a URL can be opened') and adds a useful behavioral note ('No browser is launched'), but the purpose is ambiguous because the input schema accepts nine unrelated params such as city, json, path, zone, and query, which the description does not acknowledge. It also does not clarify what 'opened' means, leaving uncertainty about whether this is a syntax check, a network reachability check, or something else.

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

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

There is no explicit guidance on when to use this tool versus siblings like browser-url-ok, normalize-url, or fetch-status. The only hint, 'No browser is launched', is a behavioral note rather than a usage rule, so an agent cannot confidently decide between this and similar 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 transparency burden. It does disclose that the query is discarded rather than stored or returned, which is useful. However, it does not say what the output is beyond a character count, whether the other accepted parameters are ignored, or whether any side effects occur.

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

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

The description is extremely short, front-loaded, and free of filler. It loses a point because its brevity omits the disambiguation needed for a tool with nine optional parameters.

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

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

For a tool with no output schema, no annotations, and nine optional parameters, the description is underspecified. An agent cannot tell which parameter to populate, whether other parameters are acceptable, or what form the returned character count takes. The schema partially compensates, but the definition as a whole is 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 baseline is 3. The description adds no parameter-specific mapping; it never says that the `query` parameter is the one to count or what should be done with the other eight optional parameters. The schema's own `query` description fills the gap, but the oversized parameter set remains ambiguous.

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

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

The description states a clear action ('Count characters') on a specific resource ('a search query') and adds a behavioral note that the query is discarded. It is enough to distinguish the tool from the sibling shape/validation tools, though it does not explicitly reference the `query` parameter or the other eight schema fields.

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

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

There is no guidance about when to use this tool instead of siblings such as memory-key-count or validate-json, nor about when not to use it. The conditions that would select this tool are implied only by the name and terse 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?

The description is a bare noun phrase and offers no information about side effects, read-only status, auth requirements, or how inputs are handled. With no annotations present, the description carries the full burden and fails to disclose any behavioral traits; note that schema parameter descriptions mention 'discarded' for some inputs, but the tool description itself does not say this.

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?

A single short sentence with no wasted words; the description is front-loaded and easy to parse, although it may be too terse 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?

With 7 parameters, no output schema, and no tool-level explanation of how inputs map to behavior, the description is grossly incomplete. There is no mention of expected inputs or outputs, so an agent cannot reliably invoke this tool.

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

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

The schema provides per-parameter descriptions, so schema coverage is high. However, the tool description contributes nothing to parameter understanding and does not explain why a Git ref, city name, or JSON text are relevant to an HTTP status code catalog, leaving a semantic gap.

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

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

The description 'Short catalog of common HTTP status codes' names a resource but lacks a verb indicating the tool's action. More critically, the input schema accepts a wide range of unrelated parameters (ref, city, json, path), so the description does not establish how these parameters relate to the stated catalog, making the purpose ambiguous and likely to mislead an agent.

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

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

No guidance is given about when to use this tool or how it differs from siblings like fetch-status, normalize-url, or validate-json. The description provides no exclusions or alternative conditions.

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?

'Prompt discarded' reveals that input is not used, which is a genuine behavioral disclosure beyond the schema. However, it does not clarify whether parameters are shape-checked, why they exist, or what the exact template format is. With no annotations present, the description carries the burden and only partially meets it.

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

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

Two short sentences with no filler, and the action is front-loaded. It is appropriately concise, though the unqualified 'Prompt' leaves slight ambiguity about whether it refers to the user's prompt or the parameter input.

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 accepts ten heterogeneous parameters and sits among shape-check siblings, yet the description never explains how these parameters relate to the template, whether they are alternatives, or when to use one over another. The lack of annotations and output schema makes this a significant gap for a tool that appears simple but is contextually complex.

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

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

The input schema already provides per-parameter descriptions (e.g., 'discarded after the shape check', 'HTTPS URL to normalize or cite'), so schema coverage is essentially complete. The tool description adds no parameter-specific meaning; 'Prompt discarded' is a generic statement, so the baseline 3 applies.

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

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

The description states a clear action ('Return a three-step thinking template') and adds a behavioral trait ('Prompt discarded'), so an agent knows it produces a template. It does not explicitly contrast with sibling shape-check tools, but the core verb+resource is unmistakable, earning a 4 rather than a 5.

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

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

No guidance is given about when to use this tool versus siblings like normalize-url, validate-json, or weather-hint. There are no conditions, exclusions, or alternative tool names, leaving selection entirely to inference.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not state that the call is read-only, what the output format looks like, or that most of the accepted input parameters appear to be discarded or used only for shape checks. The schema hints at this, but the description itself leaves important behavior undisclosed.

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

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

The description is a single, front-loaded sentence with no filler. Every word earns its place, and the core purpose is communicated immediately.

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 nine-property input schema, no output schema, and no annotations, this one-sentence description is insufficient. It does not tell the agent which parameter to supply, how to interpret the unrelated-looking fields, or what the returned time value looks like. The agent would need to rely heavily on the schema to invoke the tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3 even without parameter details in the description. The description adds no real meaning beyond the schema: it matches the 'zone' parameter but says nothing about the other eight parameters or their discard 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 states a specific resource and action: returning the current time for a named IANA timezone. It is not a tautology and helps distinguish from siblings like iana-zones or utc-time, but it does not explicitly contrast them or account for the broader input schema.

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

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

The description implies when to use the tool: whenever the agent needs the current time for a specific IANA timezone. However, it gives no explicit guidance about alternatives or situations where this tool should not be used, relying on the agent to infer from sibling names.

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

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

With no annotations provided, the description must disclose behavior, but it only states the output. It fails to mention that all input parameters are unrelated to the timestamp and are discarded or validated, leaving the agent unaware of the tool's actual handling of arguments beyond the empty call.

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, with no wasted words. However, it is so terse that it omits crucial context about the parameter list, so the conciseness is not fully appropriate given the schema complexity.

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 unexpected array of parameters with varied descriptions (e.g., 'normalize or cite', 'discarded after shape check'), the description is incomplete. An agent cannot understand why the tool accepts these unrelated inputs or whether they change the behavior, making the definition inadequate for correct invocation beyond a no-argument 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?

While the schema descriptions for each parameter are detailed, the tool description 'Current UTC timestamp.' does not explain how these parameters relate to the tool's function. It is unclear whether they are required, optional, or strictly ignored, creating confusion for an agent deciding what to pass.

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 tool's primary function: returning the current UTC time. It is unambiguous and distinguishes it from timezone-related siblings like 'timezone', but it lacks an explicit verb and does not account for the numerous input parameters in the schema.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'timezone' or 'iana-zones'. It does not state whether parameters should be supplied, ignore alternative time sources, or any other selection criteria.

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

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

The description discloses one important behavior: 'The body is discarded,' indicating the tool does not persist input. No annotations are present, so this partial transparency is helpful, but it does not explain what happens on invalid JSON or what the tool returns beyond the implied validation result.

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

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

The description is efficiently worded and front-loads the core purpose immediately. It avoids fluff, though it is arguably too terse to be considered excellent.

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

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

With no output schema and no annotations, the description should explain expected outcomes more fully. It leaves unclear what the tool returns for valid versus invalid input, and the presence of many seemingly unrelated parameters is not reconciled with the stated purpose.

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

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

The input schema already provides descriptions for all seven parameters, so the description adds little beyond a general reference to 'the body.' It does not clarify which parameter should be treated as the JSON body, though the schema's 'json' property is reasonably self-explanatory.

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 a specific action—checking whether a body is valid JSON—and the tool name reinforces this. It does not explicitly distinguish itself from sibling validators like domain-shape or wiki-title-ok, but the JSON-specific focus is evident.

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 an agent needs to determine whether a JSON body is valid, but it does not provide when-to-use versus alternative validators, exclusions, or prerequisites. Usage context is clear but not elaborated.

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 behavioral burden, but it only states the core function and source. It does not disclose that most schema fields appear to be discarded or irrelevant, what units or response format are returned, or any error or network behavior. This is materially thin for a 9-parameter tool.

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

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

One short sentence with no filler, and the key resource and source are front-loaded. It is efficient but minimal, containing no parameter mapping or usage context, so it earns strong but not maximal conciseness credit.

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

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

With no output schema, no annotations, nine optional parameters, and a large sibling list, a one-sentence description is incomplete: an agent cannot tell which parameter to supply, what the return value looks like, or whether non-weather params are ignored. These are important gaps 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 schema already documents every parameter, yielding a baseline of 3. The description adds only the weather context for 'city' and does not identify it as the sole relevant parameter or explain the other eight optional fields.

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 'Current temperature for a city via Open-Meteo' names a specific resource (city temperature) and source, and weather-hint is distinct from siblings like geo-hint and lib-docs-hint. It lacks an explicit verb such as 'get' or 'return', and the schema contains many unrelated parameters, so it stops short of 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 description implies use when a current city temperature is needed, and the sibling set makes the weather domain apparent. However, it gives no explicit when-to-use or when-not-to-use guidance and names no alternatives, so the agent must infer selection from the tool name and domain.

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, and it does disclose two meaningful traits: it is limited to public URLs and the response body is discarded. It does not mention redirects, timeouts, or output format, but the main data-handling behavior is stated.

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 front-loads the core result and follows immediately with the discarded-body caveat. There is no filler or repetition.

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 a nine-parameter schema, no output schema, and many sibling tools with overlapping purposes, the description covers only the URL-fetch use case and does not explain the other accepted parameters or how to choose among siblings. An agent would be uncertain about invoking it outside the simplest url case.

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

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

Schema coverage is 100%, so the baseline is 3; the tool description adds only generic URL context and leaves the nine optional parameters unexplained. It also slightly clashes with the url parameter's 'normalize or cite' wording, though it does not contradict it.

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

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

The description states a specific verb-resource-result: return HTTP status and content type for a public URL. It is clear and not a tautology, but it does not distinguish itself from sibling tools 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?

It provides context (public URL, status/content-type check, body not returned) that implies when to use it, but it never names alternatives or gives an explicit when-not-to-use condition. The 'Body discarded' note is the closest thing to an exclusion.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does state that the title is discarded after the call, which is a useful data-retention trait. However, it does not disclose whether the tool makes a network request, how the existence result is returned, or any error/rate-limit behavior. The single behavioral note is insufficient.

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

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

The description is extremely concise, containing only two sentences with no filler or repetitive information. The primary purpose is front-loaded, and every word serves a function. This is an efficient and well-structured brief description, even though it omits critical details covered in other dimensions.

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

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

The description is inadequate for the tool's complexity. With no output schema, no annotations, and a seven-parameter input schema, the description fails to explain which parameter holds the Wikipedia title or what the result of the existence check looks like. An agent cannot safely invoke this tool based on the provided information.

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

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

The input schema lists seven string parameters (ref, url, city, feed, host, json, path) whose descriptions all revolve around shape checks and discarding, with none mentioning 'title'. The tool description says 'Check whether a Wikipedia title exists' but never maps the title to any schema parameter. This leaves the agent unable to determine which field to populate, a critical gap. The high schema coverage is irrelevant because the descriptions are generic and do not align with the tool's purpose.

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

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

The description clearly states the tool's action ('Check whether a Wikipedia title exists') with a specific resource (Wikipedia title), distinguishing it from sibling tools like browser-url-ok or domain-shape which target different resources. The verb 'check' and the object 'Wikipedia title' are unambiguous.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or conditions. An agent cannot determine whether to choose wiki-title-ok over siblings such as web-fetch or normalize-url. There is no stated context or exclusion that would help route the call.

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