ISO country NC

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

The description discloses a meaningful behavioral trait: 'Task text discarded' indicates the input task is not retained. It also states what the tool returns. However, with no annotations and no output schema, it does not clarify whether network calls are made, whether anything is executed, or what side effects might 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 three short sentences with no filler. The main purpose is front-loaded, and each sentence adds distinct information: what it finds, what it returns, and a key behavioral caveat.

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 unrelated optional parameters, no annotations, and no output schema, yet the description does not explain how the parameters relate to the stated purpose or whether calling with no arguments is sufficient. It describes return items at a high level but leaves enough ambiguity that an agent may not know how to 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 coverage is 100%, so the description does not need to repeat parameter meanings. The schema already documents each parameter, including discard/no-disk-access notes. The description adds no parameter-level guidance on how to choose among the nine 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 clearly names a specific action and resource: 'Find a public pay-per-call tool gateway (Monid)' and lists concrete outputs. It is distinguishable from the sibling tools, though it leaves 'Monid' unexplained and does not clarify whether this is a search or a 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?

The description provides a clear use context: use this tool to locate the Monid gateway and obtain CLI setup, how-it-works info, skill file, and remote MCP hops. It does not explicitly mention when not to use it or name alternatives, but the purpose is specific enough to guide selection.

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

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

With no annotations, the description must disclose behavior itself. It only says no browser is launched, but does not state whether the check performs a network request, what success/failure looks like, whether the input is validated locally, or what side effects occur. The 'discarded' schema notes are not part of the tool 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; the primary purpose is front-loaded and the no-browser caveat is useful. It is concise, though somewhat at the expense of necessary detail.

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

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

For a tool with nine optional heterogeneous parameters and no output schema, the description is incomplete. It omits the return value, error/status behavior, which parameter is required for the URL check, and how it relates to the many 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?

Schema coverage is 100%, but the schema itself is confusing for this tool: 'url' is described as 'HTTPS URL to normalize or cite' and several other optional params (ref, city, feed, json, path, query) are unrelated to the stated purpose. The description adds no mapping from its purpose to any parameter, so an agent cannot tell 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 a clear action and object: 'Check whether a URL can be opened,' and adds a differentiator in 'No browser is launched.' It does not fully explain what 'opened' means (syntax check vs reachability), but it is specific enough to separate from browser-launching 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?

There is no guidance on when to choose this tool over siblings like playwright-url-ok, fetch-status, or normalize-url. The no-browser sentence hints at a lightweight use case, but no explicit when/when-not conditions or alternatives are given.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals one useful trait: the expression is discarded, implying no persistence. But it does not state whether the tool returns a computed result, writes anything, or errors on invalid input, leaving the agent without essential 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 this is under-specification rather than genuine conciseness. Every word must earn its place, and here the two clauses omit critical invocation details while leaving a misleading reference to a nonexistent expression parameter.

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 parameters, no annotations, and no output schema, so the description is the only source of guidance. It is completely inadequate: it does not map the arithmetic expression to any parameter, does not describe the return value, and gives no indication how this tool fits with the many sibling shape-check tools. An agent cannot reliably 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, but the description actively misleads by referring to an 'expression' that does not appear among the nine schema properties. None of the parameters (ref, url, city, feed, host, json, path, query) is identified as the arithmetic expression, so the agent cannot determine where to put the expression when invoking the tool.

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

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

The description states a specific operation, 'Evaluate a+b style arithmetic', which distinguishes it from the URL/path/domain shape-check siblings. However, it is vague about what 'evaluate' yields, and the added phrase 'Expression discarded' obscures whether a result is returned. The schema contains no expression parameter, so the stated purpose does not cleanly connect to the tool's actual inputs.

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

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

No usage context is provided: there is no statement of when to prefer calc-eval over alternatives, no exclusions, and no examples. The only hint is the bare description, which does not say under what conditions an agent should invoke this tool.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It adds one meaningful guarantee: 'Page content is not stored.' However, it does not disclose whether the URL is fetched server-side, what happens on failure, whether external requests are made, or how the unrelated params behave in terms of side effects.

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

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

The description is short and front-loaded, stating the primary action in the first sentence. Every sentence earns its place, though the brevity leaves significant gaps in coverage.

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

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

This is a nine-parameter tool with no output schema, yet the description only addresses URL-derived output. It does not explain what result the caller should expect for ref, city, feed, host, json, or path inputs, nor does it offer examples or error semantics. For an agent to invoke this tool with confidence across its declared parameters, substantially more context is needed.

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 nine parameters, so high schema coverage sets a baseline of 3. The description adds context for the url param (return host, scheme, and HTTP status) but adds no meaning for the other eight params, which remain disconnected from the stated purpose.

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

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

The description names a specific action and output ('Return host, scheme, and HTTP status for a URL'), which is clear for a URL-related subset of the tool. However, the input schema lists nine params including city, feed, json, ref, and path that the description never connects to, so the tool's overall purpose is ambiguous. It also does not distinguish itself from siblings like fetch-status or domain-shape.

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

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

There is no explicit guidance about when to use this tool versus siblings such as fetch-status, normalize-url, or web-fetch. The phrase 'Page content is not stored' implies a safe/privacy-conscious choice, but it does not state when this tool should be 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, the description carries the full burden of behavioral disclosure. It adds one useful privacy statement, 'No identifiers are retained,' but does not explain what the tool does beyond classification, whether it makes external calls, or what side effects, if any, 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 two sentences are tight, front-loaded, and contain no fluff; the purpose statement comes first and the privacy note second. It is perhaps too terse to be fully useful, but structurally it is concise.

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 carry substantial context. It fails to state what classification outputs look like, how parameters map to classifications, or when this tool should be invoked, leaving an agent under-informed.

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 all nine parameters already have meaningful descriptions. The tool description adds only a general retention guarantee and no per-parameter meaning, which matches the baseline for high schema coverage.

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

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

The description says the tool will 'show how this request is classified,' which conveys a classification/shape-checking purpose but leaves the classification scheme undefined. It does not distinguish this tool from its many siblings, making the purpose only minimally 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?

No guidance is given about when to use this tool versus alternatives such as normalize-url, validate-json, or file-path-ok. The description provides neither explicit when/when-not conditions nor references to 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 provided, the description carries the full burden of behavioral disclosure. It does disclose that no WHOIS or ownership data is included, which is helpful, but it does not describe return format, error handling, or the fact that many schema parameters are 'discarded after the shape check.' This leaves significant behavioral ambiguity for an agent.

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. It states the core action and the key exclusion ('without WHOIS or ownership data') efficiently.

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 tool having nine optional parameters and no output schema, the description gives no details about expected output structure, input constraints, or behavior for invalid hostnames. It also does not explain the schema's 'discarded' semantics, leaving an agent without enough context to invoke the tool confidently in edge cases.

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 nine parameters, including that most are discarded after checks. The description adds a 'hostname' to 'labels' mapping that aligns with the host parameter, but it does not clarify the role of the other optional parameters. Baseline 3 is appropriate given the high schema coverage.

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

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

The description uses a specific verb and resource: 'Split a hostname into labels.' It also adds a clear negative scope, 'without WHOIS or ownership data,' which distinguishes it from lookup or ownership-oriented sibling tools. This is enough for an agent to tell domain-shape apart from URL normalization, fetching, and other shape-check 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: when you need hostname label splitting and explicitly do not want WHOIS or ownership data. However, it does not name alternatives or state when-not-to-use it relative to sibling tools like normalize-url, file-path-ok, or figma-url-shape, so the guidance is implied rather than explicit.

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

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

With no annotations, the description carries the full disclosure burden. It discloses the HTTP method (HEAD) and that only status is returned, but it does not explain what happens with the many optional schema parameters (ref, city, json, query, etc.), how no URL is handled, or what error/status values are possible. The schema's parameter descriptions even suggest unrelated behaviors like normalization, validation, and hints, which the description never reconciles.

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, no filler, and the core behavior is front-loaded. The description earns its place with the method, scope, and return restriction.

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 eight optional parameters, no annotations, and no output schema, a single sentence is inadequate. It does not explain parameter selection, mutual exclusivity, return format, or how it relates to the sibling URL-status tools.

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

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

All parameters have schema descriptions, but the description adds no parameter meaning: it never identifies which parameter is the URL to HEAD or how the optional fields relate. The schema itself is inconsistent with the description (e.g., url is described as 'HTTPS URL to normalize or cite' rather than as a HEAD target), so the high coverage does not actually help an agent call 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 states a specific operation: HEAD a public URL and return only the status. This is clear about the verb, resource, and output, and 'status only' distinguishes it from a full fetch. It does not explicitly differentiate from sibling URL-checking tools such as browser-url-ok or playwright-url-ok.

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

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

There is no guidance on when to use this tool instead of alternatives. The only scope hint is 'public URL', with no mention of browser checks, no-body checks, or when web-fetch would be preferable.

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

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

With no annotations, the description carries the transparency burden. It discloses one meaningful trait: the path is discarded, so callers should not expect path-dependent behavior. It does not describe return values or network/side-effect behavior, but 'parse' implies a read-only local operation and no annotation contradicts it.

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

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

The description is very short, front-loaded, and contains no filler; both sentences carry intent. It is slightly fragmentary ('Path discarded') and arguably too terse to anchor a 9-parameter schema, so not a perfect 5.

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, yet the description never states what the tool returns (file key, validation status, normalized URL?), nor does it explain how the 9 optional parameters relate to Figma URL parsing. An agent has enough to guess the input but not the call contract, so the definition 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?

The schema already documents all 9 parameters (100% coverage), so the baseline is 3. The description adds the crucial qualifier that the URL should be a Figma URL and appears to render the path irrelevant, but it does not map all schema parameters or explicitly state which of the nine should be provided.

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

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

The description names a concrete action ('Parse') and target ('Figma file URL'), and adds a behavioral qualifier ('Path discarded'), so an agent can tell this is a URL parser rather than a fetcher. It does not explicitly name sibling alternatives, but the Figma-specific target is sufficiently distinct.

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 use is implied: when a Figma file URL needs to be parsed or shape-checked. However, there is no explicit when-to-use guidance, no mention of alternatives such as normalize-url or browser-url-ok, and no statement about when not to use this tool.

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

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

With no annotations provided, the description carries the burden and does add a key behavioral fact: no disk access occurs, meaning the operation is a pure shape check with no side effects. It does not explain what 'safe' means, what conditions cause failure, or what the tool returns, but for a simple predicate-style check the disclosure is acceptable.

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 core purpose is front-loaded and the 'No disk access' sentence adds meaningful safety context. 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 is simple, but with no output schema and no annotations, the description should at least specify the return contract and define what 'safe' means. The schema lists nine parameters while only one is clearly relevant, and the description does not resolve that ambiguity or provide enough context for an agent to confidently use the tool among many similar siblings.

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 description adds no parameter-specific detail beyond echoing the word 'path.' The description also does not clarify why the schema contains many unrelated parameters, which limits its 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 uses a specific verb ('Check'), names the resource ('a path'), and adds the useful qualifier 'looks safe' plus 'No disk access.' It is clearly not a tautology and conveys that this is a validation/safety check rather than a filesystem operation. It does not explicitly differentiate from sibling shape-checking tools, but the file-path focus is reasonably distinct.

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 tool is appropriate when only a syntactic/safety check is needed and filesystem interaction must be avoided. However, the description does not state when to use this tool over alternatives like browser-url-ok or normalize-url, nor does it provide exclusions or explicit 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 carries the full burden of behavioral disclosure. It only states that coordinates come from Open-Meteo; it does not explain network dependency, which fields are used, what happens with missing or invalid input, or what the response structure is. The schema's 'discarded after...' notes add more confusion than clarity.

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

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

The description is a single concise sentence with no wasted words, and the key output and data source are front-loaded. It could be improved with a verb and a hint about the relevant parameter, but it is appropriately brief.

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

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

For a tool with 9 optional parameters, no annotations, and no output schema, one sentence is insufficient. The description does not specify which parameter supplies the place, what the returned coordinates look like, or how failures should be handled, leaving an agent poorly equipped to call the tool correctly.

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

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

Schema coverage is 100%, so the input schema already describes every parameter individually. The description adds no parameter-level meaning and, more importantly, fails to connect the tool's stated purpose to any specific parameter such as city or query. Baseline 3 applies because the schema does document parameters, but the disconnect leaves a real gap.

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

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

The description clearly states the core output—latitude and longitude for a place—and identifies Open-Meteo as the data source. It is specific enough to distinguish geo-hint from siblings like weather-hint, though it lacks a verb and does not name which input parameter represents the place.

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 tools such as weather-hint or timezone, no prerequisites, and no mention of what inputs are expected. Usage context must be inferred entirely from the tool name and the one-line 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 full burden of behavioral disclosure. It only states the high-level parse operation and omits normalization behavior, error handling, return format, and the fact that many schema parameters are discarded. This is minimal transparency, not a contradiction.

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 sentence with no filler; every word contributes to the meaning. It is appropriately compact, though it sacrifices behavioral context that could have been provided without much additional length.

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

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

For a 9-parameter tool with no output schema and no annotations, the one-line description is thin. It identifies the task and the general output but does not specify the primary parameter, the return structure, or how unrelated parameters are treated. Schema descriptions partially mitigate the parameter ambiguity, making it minimally adequate rather than fully incomplete.

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

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

The schema provides descriptions for all parameters at 100% coverage, establishing a baseline of 3. The description adds only the context that a GitHub URL is the relevant input, but it does not name the 'url' parameter or clarify how the many unrelated parameters should be handled.

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 precise action ('parse') and target ('owner and repo from a GitHub URL'), which clearly distinguishes it from sibling shape tools like figma-url-shape and jira-key-shape. There is no ambiguity about the core function.

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 'GitHub URL' implies when the tool should be used, but there is no explicit statement of alternatives or when not to use it. The usage context is implied rather than directly contrasted 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?

No annotations are provided, so the description must carry the behavioral burden. It discloses only that titles are discarded, but does not state whether the tool is read-only, whether it performs a network fetch, whether the optional parameters are ignored, or what the exact output shape is. This is insufficient for a tool with no annotation coverage.

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 brief and the core function is front-loaded in the first sentence. The second sentence, 'Titles discarded,' is short and adds a behavioral detail, though it is a fragment and its referent is somewhat ambiguous, which keeps it from a perfect 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 and no annotations, the description leaves important operational details unspecified: return type or format, whether parameters are simply ignored, and what 'current' means in terms of data freshness. The unusual nine-parameter schema makes this gap more significant, as the agent gets little guidance 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 description is not required to restate parameter meanings. Still, it adds no real semantic value beyond the schema; 'Titles discarded' is a loose echo of the feed parameter's description and does not help an agent understand why the tool accepts nine unrelated 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 states a specific verb ('Count') and a specific resource ('current Hacker News front-page stories'), and the added note 'Titles discarded' clarifies that only the count is returned, not story content. This clearly distinguishes the tool from the many sibling tools that fetch, check, or validate URLs and files.

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 usage context: call this tool when you need the number of current Hacker News front-page stories. However, it provides no explicit when-not-to-use guidance and names no alternative tools, leaving the agent to infer boundaries such as 'use web-fetch if you need story details.'

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 full behavioral burden. It discloses no side effects, return shape, or operation; 'names for clock calls' could mean a lookup, a constant list, or a validator. This is insufficient for safe invocation.

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

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

At one sentence, the description is terse and front-loads 'IANA timezone names.' However, it is under-specified for a tool with 9 parameters and no annotations; brevity comes at the cost of substance.

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

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

There is no output schema, no annotations, and the description never states return values or the form of the zone list. With 9 parameters and sibling time tools, an agent lacks enough information to call it 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?

Schema coverage is 100%, so the baseline 3 applies. The description adds no parameter meaning, and the optional params (ref, url, json, path) are orthogonal to timezone names, though each schema description already documents its own meaning/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 is a noun phrase with no operating verb: it does not say whether the tool returns a list, validates names, or maps aliases. 'iana-zones' and 'IANA timezone names' are near-tautological, and it only obliquely separates from siblings like timezone/utc-time via 'for clock calls.'

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?

'for clock calls' provides a weak usage context, suggesting the tool is a source of canonical zone names before calling time-related tools. It does not name alternatives, state when not to use it, or mention exclusions, so guidance is merely implied.

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 indicates a read-oriented network fetch and a summarized return, but it does not disclose how the target is selected, how failures or missing robots.txt files are handled, or what 'group counts' actually means in the response.

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. It effectively states the action and the output restriction, though it omits important contextual details that could have been included without much extra length.

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

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

Given no output schema, no annotations, nine optional parameters, and no indication of which parameter supplies the robots.txt location, an agent cannot reliably know how to invoke this tool. The phrase 'group counts only' gives only a high-level return expectation, not a concrete callable contract.

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 nine parameters. However, the description adds no mapping between those parameters and the robots.txt target, leaving ambiguity about whether to pass url, host, or path. This is baseline adequacy with no added 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 uses a specific verb ('Fetch') and resource ('public robots.txt') and defines the output ('return group counts only'), so an agent can understand the core purpose. It does not explicitly differentiate it from siblings like web-fetch or normalize-url, which keeps it from 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?

There is no guidance about when to choose this tool over web-fetch, fetch-status, normalize-url, or other sibling tools. The only usage signal is implied by the action itself; no exclusions, prerequisites, or alternative routing are provided.

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

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

With no annotations provided, the description carries the behavioral burden. 'Key discarded' adds some transparency by implying no retention or side effects, but it does not describe the return value or behavior for invalid shapes. This is minimal but not misleading.

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, with each sentence serving a purpose: stating the action and noting the input is discarded. It is concise, though the terse style contributes to the missing parameter linkage.

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 no annotations and no output schema, the description is under-specified for a tool with seven parameters. It does not explain what constitutes a valid Jira key shape, which parameter to supply, or what the tool returns. An agent would struggle to 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?

Although every schema property has a description and coverage is high, the critical ambiguity remains: none of the seven parameters is explicitly identified as the Jira key input. The description mentions 'Key discarded' but does not link it to a specific field such as ref, url, or path, so an agent cannot confidently select the right parameter.

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

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

The description clearly names the resource and action: 'Check a Jira issue key shape.' This distinguishes it from sibling shape tools like domain-shape or figma-url-shape. However, it does not specify which input parameter carries the key, leaving some ambiguity.

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

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

No guidance is given about when to use this tool versus alternatives such as github-repo-shape or file-path-ok. There are no explicit conditions, exclusions, or references to sibling tools, so the agent must rely solely on the tool name.

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

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

With no annotations, the description carries the full disclosure burden. It does reveal one meaningful behavioral trait: the body is discarded, so only the HTTP status is relevant. It does not mention network behavior, redirects, error handling, auth, or rate limits, but for a simple status probe the stated behavior is minimally 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?

Two short sentences, front-loaded with the action and target. There is no filler, no restatement of the schema, 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?

For a 9-parameter tool with no annotations and no output schema, the description is too sparse. It does not explain which parameter to provide, what happens with the other accepted parameters, what the HTTP status result looks like, or how this tool relates to siblings like fetch-status, browser-url-ok, and web-fetch.

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% per-parameter description coverage with explicit 'discarded' notes, so the baseline is 3. The tool description itself adds little parameter meaning beyond narrowing the URL concept to 'public library docs', and it does not clarify which of the nine optional parameters are expected.

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

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

The description names a concrete action ('HTTP status') and a specific target ('public library docs URL'), and adds that the response body is discarded. It is not a tautology and is reasonably distinguishable from generic fetch-status tools because of the docs-URL restriction, though it does not explicitly differentiate itself from 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 'public library docs URL' and 'Body discarded' imply this is for lightweight status checks where content is not needed. However, there is no explicit when-to-use or when-not-to-use guidance, and no alternative tools such as fetch-status or web-fetch are named, so the boundary must be inferred.

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 disclosure burden. It reveals that values are discarded, but it does not state what the tool returns, how invalid JSON is handled, or which input provides the JSON object. 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 very short and front-loaded: two sentences with no filler. It is appropriately concise for a simple counting operation, though it leaves important contextual details to 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?

Given no output schema, no annotations, and seven-plus parameters, the description is incomplete. It fails to identify which parameter should be used, what the output shape is, and what happens on 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 coverage is 100%, so the parameter names and descriptions already document the inputs. The tool description does not connect 'JSON object' to the 'json' parameter, but the schema largely compensates.

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'), so an agent can tell this counts keys rather than validating or fetching. It doesn't explicitly name a sibling to differentiate from, but the action itself is distinct enough.

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

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

There is no guidance about when to use this tool versus siblings like validate-json or domain-shape. 'Values discarded' implies a use case where only key names matter, but that is not made explicit.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose the key transformation ('Query and fragment are dropped'), which is useful, but it stays silent on invalid-URL handling, output format/type, and whether anything else is mutated or filtered. For a simple read-only normalizer this is minimal but not 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 sentences, front-loaded with the main behavior and followed by a precise caveat. Every word earns its place; no filler or repetition of the tool name.

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

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

No annotations and no output schema, so the description must cover the essentials. It states outputs (origin, host, path) and dropped parts (query, fragment), but it never says which input parameters to provide, and the schema confusingly lists 'host' and 'path' as inputs even though the description implies they are outputs. Error behavior and return structure are also unspecified, leaving a real gap for a 9-parameter tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds minimal semantic value by implying 'url' is the operative parameter ('for a URL'), but it does nothing to disambiguate the eight other schema params (city, feed, json, zone, query, ref), several of which are clearly unrelated to URL normalization and would confuse an agent.

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 ('Return'), resource ('origin, host, and path'), and domain ('for a URL'), then adds the transformation detail ('Query and fragment are dropped'). This clearly differentiates it from URL-related siblings like web-fetch or browser-url-ok, which serve different purposes.

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 guidance and names no alternative tools. An agent can infer 'use when you need origin/host/path' from the purpose statement, but there is no exclusion or comparison with the many URL-related siblings (fetch-status, web-fetch, browser-url-ok, figma-url-shape), so it barely rises above no 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, the description carries the behavioral burden. It does add one useful trait: no browser is launched. But it does not disclose whether a network request is made, whether the operation is read-only, or how failures/errors are represented, so transparency is 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?

Two brief sentences with no filler; the core action and the key negative behavior are front-loaded. This is appropriately sized for a simple checker.

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 heterogeneous optional parameters, no output schema, no annotations, and numerous similar siblings, the description omits essential context: what result is returned, what 'ok' means, whether extra parameters are alternative inputs, and what side effects (if any) occur. The schema cannot compensate for the missing return and selection semantics.

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%: every one of the 9 parameters has a description in the schema, so the baseline is 3. The tool description itself adds no parameter-level meaning and even narrows attention to URL, but the structured schema already documents 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 gives a real action — 'check whether a URL can be opened' — and one differentiator ('No browser is launched'). However, 'opened' is left undefined (syntactic validity, HTTP reachability, or rendering?), and the stated purpose covers only URL while the schema exposes eight other optional parameters (city, feed, json, path, zone, query, host, ref), making the scope unclear.

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

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

There is no explicit statement about when to choose this tool instead of a sibling such as browser-url-ok, fetch-status, or normalize-url. The 'no browser' sentence only implies a browserless context and never says when to use or avoid the tool.

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

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

The 'Query discarded' sentence is a useful behavioral disclosure, especially with no annotations present to indicate side effects or persistence. However, the description does not explicitly state that the operation is read-only or what the return behavior is, so the behavioral burden is only partially carried.

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

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

Two short sentences, front-loaded with the purpose, with a non-redundant behavioral note. There is no filler, repetition, or 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?

For a simple counting utility with a fully documented input schema, the description is nearly sufficient for invocation. The main gap is the lack of an explicit return value/type, but 'Count characters' makes an integer count the natural inference. The discard behavior is also clearly stated.

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 met without additional parameter explanation in the tool description. The description aligns with the 'query' parameter but adds no meaning beyond what the schema already provides. Other parameters are already individually documented as discarded or checked.

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: counting characters in a search query, and adds that the query is discarded. This goes beyond a tautology and conveys the core function. It does not explicitly differentiate itself from sibling count/shape tools, but 'search query' narrows the resource enough to be mostly 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 on when to use this tool versus alternatives such as memory-key-count, hn-front-count, or the URL/shape validation tools. The description implies a general use case but provides no exclusions, prerequisites, or alternative routing, leaving the agent to infer applicability.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only says the catalog is 'short,' revealing nothing about side effects, return behavior, discarded inputs, or what happens with the seven parameters.

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

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

The description is brief and free of filler, but it is under-specified rather than appropriately concise. For a tool with seven input parameters and no annotations or output schema, this level of brevity does not earn 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?

With no annotations, no output schema, and a complex seven-parameter input schema, a one-clause description is wholly inadequate. The definition lacks any explanation of the tool's return value, parameter usage, or edge cases.

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 descriptions for all properties, so coverage is high and the baseline is 3. The tool description adds no meaning about how these parameters relate to the HTTP status-code catalog, but the schema already documents each parameter individually.

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 that restates the tool name ('status-catalog' -> 'catalog of common HTTP status codes') and does not specify a verb, action, or output. It fails to say whether the tool returns a lookup table, resolves a status, or validates input, and it does not distinguish itself from sibling tools like fetch-status.

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

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

There is no guidance about when to use this tool versus alternatives such as fetch-status or normalize-url. No conditions, exclusions, or contextual triggers are mentioned.

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

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

With no annotations, the description must carry behavioral disclosure. It does reveal a key trait: the prompt is discarded, suggesting the output is fixed and the tool has no memory/state. However, it does not specify side effects, error behavior, or whether all nine parameters are ignored, so coverage is 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?

Two short sentences with no filler; every word contributes. It is concise to the point of minimalism.

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, so the description should explain what the three-step template actually contains, but it does not. With 9 optional parameters and no usage context, an agent cannot tell how or whether to populate them, making the definition incomplete.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds only the general hint that the prompt is discarded, while the schema already documents per-parameter discarding; no additional semantic meaning is provided.

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

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

The description names a concrete action ('Return a three-step thinking template') and a clear resource, which is enough to differentiate it from the sibling validators and fetchers. It does not define what the three steps are, so it falls short of a 5.

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

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

No guidance on when to call think-steps versus the many sibling tools; no exclusions or alternatives. 'Prompt discarded' implies inputs are irrelevant, but the description never states a use case or triggers.

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

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

No annotations are provided, so the description carries the full burden. It discloses only the high-level result and not behavioral details such as how the time is obtained, error behavior, return format, or whether any side effects occur. This is minimal transparency for a tool with no annotation support.

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, front-loaded, and free of filler. It earns its place, though it is a fragment and could have included a verb or a brief pointer to the expected timezone parameter without losing conciseness.

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

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

With 9 parameters, no output schema, and no annotations, the description must explain how to call the tool, but it does not identify the timezone parameter, the return value, or usage examples. The schema and description appear disconnected, so the definition is not complete enough 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?

The description mentions a 'named IANA timezone', yet no such parameter appears in the schema; the exposed parameters are unrelated fields like ref, url, city, feed, host, json, and path. An agent cannot map the described behavior onto the actual input schema, making the parameter guidance 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 phrase 'Current time in a named IANA timezone' clearly identifies the resource and result, and distinguishes this from siblings like utc-time and iana-zones. It is not a tautology, though it is a noun phrase rather than an explicit verb+resource statement.

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 current time for a specific IANA timezone is needed, but it does not state when not to use it or mention alternatives. There are no explicit exclusions or routing guidance beyond the core 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?

The description discloses only that the tool returns a UTC timestamp, with no mention of output format, precision, or side effects. More importantly, it does not explain that the seven input parameters are effectively ignored or discarded, even though the schema repeatedly notes 'discarded'; the description leaves this behavioral ambiguity unresolved.

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

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

The description is very concise: a single, front-loaded sentence with no filler. It is appropriately short for a simple operation, though it could have used one or two additional clauses to clarify that 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 seven schema parameters, no annotations, and no output schema, this one-line description is not enough for reliable invocation. The agent is left uncertain about whether parameters affect behavior, what the return format is, and how this relates to sibling timezone capabilities.

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

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

All seven parameters already have descriptions in the schema, so baseline schema coverage is high and the description adds no parameter-level meaning. While the schema's 'discarded' notes hint that parameters are irrelevant, the description itself contributes nothing beyond the core timestamp 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 phrase "Current UTC timestamp" clearly identifies what the tool returns and the timezone, which distinguishes it from sibling tools like timezone or iana-zones. It lacks an explicit verb like "returns," but the meaning is unambiguous and matches the tool name.

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

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

The description gives no guidance about when to use this tool versus alternatives such as timezone, nor does it state whether arguments are required. An agent cannot tell from the description alone whether to pass any of the seven schema parameters or simply request the current 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?

There are no annotations, so the description carries the burden. It does disclose that the body is discarded, which signals non-persistence and a side-effect-free check. However, it does not describe the return value, how validity is reported, error behavior, or any prerequisites, 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 extremely concise and front-loaded: the first sentence states the purpose, and the second adds a behavioral note. There is no filler or redundant restatement.

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 no annotations, no output schema, and a seven-property input schema with several unrelated-looking fields, the description is too thin. It never explains which parameter is 'the body,' whether any parameters are required, or what the agent should expect as a result, leaving important context implicit.

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

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

All seven properties have descriptions in the input schema, so schema coverage is essentially 100%. The description adds no real parameter semantics beyond what the schema already says, especially since the `json` property is already described as 'JSON text to validate; discarded after the check.'

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

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

The description clearly states the action ('Check whether') and the resource ('a body is valid JSON'), so an agent can tell this is a JSON validation tool. However, it does not differentiate against sibling shape-checking tools such as domain-shape or file-path-ok, and the term 'body' is somewhat vague.

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

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

The description gives no guidance about when to use this tool versus alternatives, no exclusions, and no context like 'Use when you need to verify that a JSON string parses successfully.' It leaves an agent to infer the use case from the name and the lone sentence.

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

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

With no annotations, the description bears the full burden of behavioral disclosure. It does reveal an external dependency ("via Open-Meteo") and implies a read-style operation, but it says nothing about response units/format, error behavior, rate limits, or the fact that 8 of the 9 schema parameters are unrelated to weather lookup and 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?

A single eight-word sentence with zero filler; every word ("Current", "temperature", "city", "Open-Meteo") earns its place and the key signal is front-loaded. It is efficient, though borderline terse enough to read as a noun phrase rather than an actionable instruction.

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

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

The tool is more complex than the description acknowledges: 9 optional parameters, no required params, no annotations, and no output schema. The one-line description does not specify which parameter to pass, what the hint looks like, or why the other parameters exist, so an agent cannot invoke it 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 reinforces that `city` is the operative parameter, but it adds no meaning beyond the schema and does nothing to resolve the ambiguity of the other eight unrelated optional parameters (ref, url, feed, json, path, zone, query), leaving an agent guessing about which are valid inputs.

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

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

The description names a specific resource and data source: current temperature, a city, and Open-Meteo. It is clear about what the tool returns, though it lacks an explicit verb and does not explicitly differentiate itself from siblings like geo-hint or lib-docs-hint.

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?

Usage is implied: use this when you need the current temperature for a city. There is no explicit when/when-not guidance, no named alternatives, and no prerequisites, so an agent must infer the selection criteria from the weather domain alone.

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

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

With no annotations available, the description carries the full behavioral disclosure burden. It does usefully state that the body is discarded, which is a meaningful behavior. However, it does not clarify that most schema parameters appear unrelated or discarded, nor does it explain redirect, error, or authentication behavior. The gap between the simple description and the complex 9-parameter schema is a transparency problem.

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 behavior, including the important 'Body discarded' caveat, is front-loaded. It earns its place and is easy to scan.

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

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

For a tool with nine optional parameters, no output schema, and many overlapping sibling tools, a two-sentence description is under-specified. The agent cannot reliably tell which input to use, why the other parameters are present, or how this tool differs from fetch-status and browser-url-ok. The definition is too thin for the actual complexity of the schema.

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

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

Schema description coverage is 100%, so the schema already documents the nine parameters and the baseline is 3. The tool description adds only that the operation concerns a public URL, which loosely maps to the `url` parameter. It does not explain which parameter is primary or why unrelated parameters like `city`, `json`, and `zone` exist, but the schema descriptions themselves carry the parameter-level 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 clearly states the operation: fetch a public URL and return HTTP status and content type, with the body discarded. It is specific enough to avoid a tautology. However, it does not differentiate web-fetch from similarly named siblings such as fetch-status, browser-url-ok, or playwright-url-ok.

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

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

The 'public URL' and 'Body discarded' clauses imply when the tool should be used: for lightweight status/content-type checks where the body is not needed. There is no explicit comparison to alternative tools and no guidance about which of the nine optional schema parameters should be supplied, so the usage guidance remains implicit.

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

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

With no annotations present, the description carries the behavioral disclosure burden. It does disclose one useful trait: 'Title discarded after the call,' indicating the input is not persisted. It does not mention return format, network behavior, or limitations, 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 two short sentences with no filler. The key action is front-loaded, and the additional discard behavior earns its place, so this is appropriately concise.

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 existence-check tool, the description states the purpose and side effect, but no output schema or annotations exist and the parameter mismatch is unresolved. The agent is missing essential information about what input represents the title and what the tool returns.

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

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

The description adds no mapping from 'Wikipedia title' to any schema property. The schema lists seven generic parameters (ref, url, city, feed, host, json, path) with unrelated descriptions, and none clearly represents a Wikipedia title. An agent cannot determine how to invoke this 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 is specific: 'Check whether a Wikipedia title exists' names a clear verb and resource, distinguishing it from sibling shape-check tools like domain-shape or file-path-ok. However, it does not indicate which input parameter carries the Wikipedia title, so the purpose is not fully 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?

The description implies when to use the tool: whenever an agent needs to verify that a Wikipedia title exists. It does not explicitly name alternatives or exclusions, but the use case is reasonably inferred from the sentence.

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