ISO country CW

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

With no annotations, the description carries the behavioral disclosure burden. It does add an important transparency note: 'Task text discarded' and several parameters being discarded after shape checks. However, it does not state whether the tool makes network calls, whether costs are involved despite 'pay-per-call', what the return format is, or how errors surface.

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 action is front-loaded and the transparency note is placed at the end. It is concise, though 'Monid' and 'MCP hops' are unexplained jargon that an agent may not know.

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

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

The tool has 9 optional parameters, no output schema, and no annotations, yet the description does not specify what a valid invocation looks like, which parameters matter, or what the returned data structure contains. Given the unusual 'discarded after shape check' semantics, an agent is left without enough context to call the tool 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; each parameter already has a meaningful schema description. The tool description only adds a high-level note that task text is discarded, without explaining which of the nine optional parameters actually affect the lookup or whether the tool can be called empty. This is adequate but not additive.

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 ('public pay-per-call tool gateway (Monid)') and a clear verb ('Find'), then lists concrete outputs: CLI setup, how-it-works, skill file, and remote MCP hops. It is distinguishable from all siblings, none of which are gateway-index tools. Slight ambiguity remains because the description does not clarify what input would drive the 'find' behavior.

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

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

The description gives no guidance about when to use this tool instead of sibling tools such as web-fetch, normalize-url, or citation, and it names no alternatives. The only implicit usage signal is that an agent should call it when it needs Monid's setup information, but no explicit conditions or exclusions 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 provided, the description carries the full behavioral burden. It usefully discloses that no browser is launched, which prevents a natural assumption based on the tool name. But it does not explain whether a network request is made, what 'opened' means, what the result looks like, or whether there are any side effects or access constraints.

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 definition is two short sentences with no filler. The core purpose is front-loaded, and the behavioral caveat 'No browser is launched' earns its place by clarifying a likely misconception. It is as compact as possible for what it conveys.

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, no output schema, and many similar siblings, a single sentence is insufficient. Missing details include the return type, the precise meaning of an 'openable' URL, how the other parameters relate to the check, and any network or safety behavior; only the no-browser fact is provided.

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

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

Schema coverage is 100%, so the baseline is 3, but the description provides no guidance for choosing among the 9 optional parameters. The schema's url description ('HTTPS URL to normalize or cite') conflicts with the tool's stated purpose of checking whether a URL can be opened, and unrelated parameters such as city, json, and timezone are unexplained, making it unclear which parameter actually drives 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 states a specific action ('Check whether a URL can be opened') and adds a key behavioral distinction ('No browser is launched'), which separates it from browser-launching tools like playwright-url-ok. However, 'can be opened' is ambiguous—syntax validation, HTTP reachability, and renderability are all plausible—and no sibling is explicitly named, so it stops short of a 5.

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

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

The description implies when to use the tool: when a caller wants an openability check without launching a browser. It does not provide explicit when-to-use versus alternatives such as fetch-status, web-fetch, or playwright-url-ok, nor does it state any exclusions or fallback 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?

There are no annotations and the description's claim that an 'expression is discarded' is misleading because no expression parameter exists. Side effects, return behavior, and error conditions are entirely 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 brief, but brevity is achieved by omitting essential information rather than by efficient communication. It is not front-loaded with actionable content.

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

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

There is no output schema, no explanation of how parameters relate to the operation, no examples, and no mention of expected results. The description leaves the tool completely underspecified.

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 descriptions, those descriptions are generic placeholders (e.g., 'Git ref name; discarded after the shape check') that bear no relationship to arithmetic evaluation. The schema provides no meaningful semantics for this tool.

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

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

The description says 'Evaluate a+b style arithmetic' but no parameter exists for the expression, and the listed parameters (ref, url, city, feed, host, json, path, zone, query) are all unrelated to arithmetic. It is impossible to tell what input should be evaluated.

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 any of the 30+ sibling tools. The description provides no context, examples, or selection criteria.

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

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

With no annotations provided, the description carries the behavioral burden and does disclose a meaningful property: page content is not stored. Still, it omits other relevant behaviors such as whether a network request is made, how redirects or errors are handled, and any rate-limit or privacy implications beyond storage.

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

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

The description is two short, front-loaded sentences with no filler. It states the core behavior first, then adds a single clarifying privacy note, making it easy for an agent to parse quickly.

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-parameter optional schema, no annotations, no output schema, and many similar sibling tools, the description is too thin. It does not clarify which parameter an agent should populate for the stated behavior, whether the other parameters are accepted but ignored, or what to pass when only URL status 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?

Schema description coverage is 100%, so the baseline applies. The input schema already documents every parameter, including which values are discarded. The description adds no parameter-level detail, and the main confusion is that it only mentions URL behavior while the schema exposes many 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 clearly states a specific verb and resource: return host, scheme, and HTTP status for a URL. It distinguishes this tool from content-fetching or normalization siblings by naming concrete outputs rather than merely restating 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 implies the main use case: obtain URL-level metadata without storing page content. However, it does not name alternatives like fetch-status, normalize-url, or web-fetch, nor does it state when those tools should be used instead.

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 burden of behavioral disclosure. It only offers 'No identifiers are retained,' which is a useful privacy note, but it does not disclose what the tool does with inputs, whether it makes network requests, or what the output looks like.

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

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

The description is short and front-loaded with a purpose statement, and the privacy phrase adds value. However, the brevity comes at the expense of substantive guidance.

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

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

With 9 optional parameters, no output schema, no annotations, and 28 sibling tools, this description is far too thin. It does not explain how to choose a parameter, what classification result to expect, or how this tool relates to the 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. The description adds no parameter-level meaning beyond what the schema already says, but it does not need to compensate for missing schema documentation.

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

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

The description says 'Show how this request is classified' but never defines what 'classified' means, what classification categories exist, or what the tool actually returns. It is not a tautology, but it is too vague to distinguish from the many sibling shape/validation tools.

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

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

There is no guidance about when to use this tool versus siblings like normalize-url, validate-json, file-path-ok, or geo-hint. The description provides no conditions, exclusions, or alternative recommendations.

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 for behavioral disclosure. It states the core transform but does not describe return values, error behavior, handling of invalid hostnames, case sensitivity, or whether the TLD is included as a label. The 'without WHOIS or ownership data' clause adds some boundary context, but much remains 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. It communicates the core action and an important limitation 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 having 9 optional parameters and no output schema or annotations, the description does not clarify which parameter to pass, why the other parameters exist, how they relate to the tool's purpose, or what the result looks like. This leaves too much ambiguity for an agent to invoke the tool correctly in many contexts.

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

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

Schema description coverage is 100%, so each parameter is individually documented in the schema. The tool description adds no parameter-level meaning and does not connect 'hostname' to the `host` parameter, but the schema already provides adequate descriptions for each field. The baseline of 3 is appropriate.

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

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

The description states a specific action ('split a hostname into labels') and a clear resource, and it distinguishes itself by explicitly excluding WHOIS or ownership data. However, it does not explicitly name the `host` parameter or clarify which of the nine schema parameters are relevant to this action.

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 'without WHOIS or ownership data' gives a weak implied boundary, but there is no explicit when-to-use guidance, no mention of alternatives among the many sibling tools, and no clarification of what to do if ownership data is needed. With nine optional parameters, the absence of usage direction is a significant gap.

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 itself must disclose behavioral traits. It does disclose that the operation is a HEAD request, that it targets a public URL, and that it returns only status. However, it does not mention redirect handling, timeouts, rate limits, or the fact that the other eight input parameters are effectively irrelevant/ignored.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes: method, target, and 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?

The tool has nine optional parameters, no output schema, and no annotations, yet the description only addresses 'url'. It does not specify the return format, whether other parameters are ignored, or how fetch-status differs from closely related URL-checking siblings. This leaves an agent with significant ambiguity when invoking the tool.

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

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

The schema has 100% description coverage, so the baseline is 3. The description adds the key semantic that 'url' is the target of the HEAD request, which is helpful. But it does not clarify how to treat the many unrelated optional parameters, and some schema descriptions (e.g., 'HTTPS URL to normalize or cite') conflict with 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 states a specific verb ('HEAD'), a specific resource ('a public URL'), and the exact output ('return status only'). This makes the tool's purpose immediately clear and distinguishes it from content-fetching tools like web-fetch.

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 about when to prefer fetch-status over sibling tools such as browser-url-ok, playwright-url-ok, normalize-url, or web-fetch. There are no stated conditions, exclusions, or alternative recommendations.

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 behavioral burden. It says 'Parse' and 'Path discarded' but does not disclose what parsing returns, whether the URL is validated/normalized, or whether the other schema parameters are ignored. The 'discarded' hint is useful but far too sparse for a tool with no structured safety annotations.

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, with no filler. However, 'Path discarded' is a cryptic fragment, and the extreme terseness creates ambiguity rather than clarity. It is appropriately short but not optimally structured.

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

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

The tool has 9 parameters, no output schema, and no annotations, yet the description only covers the URL parsing intent. It does not explain the role of the other parameters, what 'shape' means in this context, or what the agent should do with the result. This is incomplete for correct invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no meaningful parameter semantics beyond the schema; 'Path discarded' only echoes what the schema already says about discarded fields. It does not explain which parameter is the primary input or how the others relate.

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 a Figma file URL.' This distinguishes it from generic URL tools and sibling shape tools like github-repo-shape or jira-key-shape. However, the second sentence 'Path discarded' is ambiguous and slightly muddies the otherwise clear purpose.

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

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

No guidance is given about when to use this tool versus alternatives such as normalize-url, browser-url-ok, or domain-shape. The description implies use for Figma URLs but provides no selection criteria or exclusions.

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

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

With no annotations provided, the description correctly adds an important behavioral fact: no disk access, meaning this is a pure syntactic check without filesystem side effects. However, it does not clarify what 'safe' means, whether any network access occurs, or what the tool returns, leaving some behavioral ambiguity.

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

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

The description is two short sentences with front-loaded purpose and no filler. Every word contributes, making it appropriately concise for a simple validation tool.

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

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

For a tool with no output schema and no annotations, the description is too sparse. It does not state what the check returns, how to treat the nine optional schema parameters, or what criteria define a 'safe' path. The no-disk-access note helps, but the agent still lacks enough context to invoke the tool 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?

All nine parameters already have descriptions in the schema, so the description itself adds no parameter-level meaning. It mentions only 'path' while the schema contains many unrelated optional parameters, so the schema carries the semantic weight for parameter interpretation.

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 purpose: checking whether a file path looks safe, with a useful scope qualifier ('No disk access'). It is clear about the resource and action, though it does not explicitly distinguish itself from sibling validators like browser-url-ok 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?

The purpose sentence implies this tool is for path-safety checks, but there is no explicit when-to-use or when-not-to-use guidance, and no mention of alternatives among the many similar 'ok' and 'shape' tools. The no-disk-access note hints at safe usage but does not provide selection criteria.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'via Open-Meteo' and gives no indication of side effects, external API behavior, rate limits, or that inputs are discarded after the 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 a single front-loaded sentence with no wasted words; it states the output and the source in the first clause. It earns its place entirely.

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

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

With 9 optional parameters, no required parameters, and no output schema, the description is too thin: it does not indicate which parameter supplies the place, what the returned latitude/longitude format looks like, or how failures are reported. An agent would need to inspect the schema and still remain uncertain.

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

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

Schema coverage is 100% and each parameter has a descriptive field, so the baseline is 3. The description's 'place' maps loosely to the city parameter but does not explicitly say to use city, so it adds little meaning 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 clearly identifies the tool's product—latitude and longitude for a place—and names Open-Meteo as the source, which distinguishes it from siblings like weather-hint or timezone. It lacks an explicit verb such as 'Get' and does not name the expected input parameter, so it stops short of a fully specific instruction.

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

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

There is no when-to-use guidance and no mention of alternatives or exclusions. An agent must infer that this tool is for geocoding and is not told which sibling tools to prefer instead.

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 alone must carry behavioral disclosure. It only states the parse operation and does not disclose that many of the nine parameters (city, feed, json, path, query, etc.) are discarded, nor does it describe error behavior for invalid or non-GitHub URLs. The parameter descriptions in the schema mention discarding, but the tool description itself adds no such context.

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 or repetition. It is efficient for stating the core purpose, though it may be too terse given the complexity of the nine-parameter schema and the lack of 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?

There is no output schema, so the description should explain the return value, but it only says 'parse owner and repo' without specifying the output format or behavior on invalid input. It also fails to reconcile why unrelated parameters like city, feed, host, json, path, and query are accepted, leaving the agent uncertain about what actually gets used.

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 tool description adds little per-parameter meaning beyond implying that the 'url' field is the relevant one for parsing a GitHub URL. It does not clarify why the other eight parameters are accepted, but the schema descriptions do document each field's role.

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 ('Parse') and a specific resource ('owner and repo from a GitHub URL'), making the tool's core function clear. It also differentiates from sibling shape tools by focusing on GitHub, though it does not mention how it differs from URL-handling siblings like 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?

Usage is implied: an agent can infer to use this tool when it needs to extract a GitHub owner and repository from a URL. However, the description gives no explicit routing guidance, prerequisites, or exclusions, and it does not mention alternatives such as normalize-url or browser-url-ok.

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

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

With no annotations, the description carries the transparency burden. It discloses that titles are discarded and implies a read-only fetch of current data, but it does not explain the return format, whether optional parameters like 'feed' change the source, network dependence, or failure behavior.

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

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

The description is two short sentences with the primary action front-loaded and a key limitation stated immediately after. There is no redundant or filler content; every word contributes to understanding the tool's scope.

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 core action is simple and clearly stated, but with no output schema and no annotations, the description should clarify what the return value looks like and how the nine optional parameters relate to the count. The schema descriptions help, but the tool-level guidance leaves those 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?

Schema description coverage is 100%, so the schema already documents every parameter, making 3 the baseline. The description adds little parameter-level guidance, though 'Titles discarded' echoes the 'feed' parameter's description and hints at its relevance.

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 a specific resource ('current Hacker News front-page stories'), so an agent immediately understands the tool's core function. The added clause 'Titles discarded' further narrows the scope and distinguishes it from tools that would return story details.

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 clear context for when to use the tool: when a current count of HN front-page stories is needed. It also implies an exclusion because titles are discarded, but it does not name alternative tools or state explicit when-not 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says what the data is, not what the tool does with inputs, whether anything is discarded, what the response looks like, or how 'common' is determined. The schema reveals that several parameters are discarded after checks, but the description itself does not convey 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?

The description is short and has no filler, but it is under-specified rather than efficiently complete. A single clause may be concise, but it does not provide enough structure or detail to support correct tool selection and invocation.

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 output schema, and no annotations, this description is inadequate. It does not explain why diverse parameters are accepted, what 'common' means, what the caller receives, or how this tool fits with timezone-related siblings. The lack of context makes the tool genuinely confusing.

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 an individual description; therefore baseline is 3 even without parameter details in the tool description. However, the description adds no meaning about how these parameters relate to IANA timezone names, and the parameter set (ref, url, city, feed, host, json, path) appears 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 is a noun phrase: 'Common IANA timezone names for clock calls.' It identifies the resource at a basic level and adds the qualifier 'common', but it lacks a verb such as 'list' or 'return', and it is close to restating the tool name. It also does not distinguish itself from timezone-related siblings like `timezone` or `utc-time`.

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

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

The phrase 'for clock calls' hints at a use context, but there is no explicit when-to-use guidance, no exclusions, and no comparison to sibling tools. An agent would have to infer when this tool is preferred over `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?

With no annotations, the description must carry the behavioral burden. It discloses the core network fetch and counts-only return, but says nothing about how the nine optional parameters are treated, whether most values are discarded, or what happens on network or parse errors.

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 adds meaning: what to fetch, what kind of resource, and what to return.

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 too sparse for a tool with nine optional parameters, no required arguments, and no output schema. It does not explain how to indicate which robots.txt to fetch, what 'group counts' means, or what happens when the target is missing or unreachable.

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

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

Although schema description coverage is 100%, the description does not help map any parameter to the robots.txt target. It never states whether url, host, or another field provides the address, and several schema parameters (city, json, zone, query) are unrelated to 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 clearly identifies the action ('Fetch'), the resource ('public robots.txt'), and the output ('group counts only'). It is specific enough to distinguish this from generic fetch or status-check tools, and no sibling appears to target robots.txt.

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 web-fetch or fetch-status. The 'only' clause hints at a limited return, but no explicit conditions, exclusions, or alternatives 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only says 'Key discarded,' which hints at lack of retention, but it does not explain what happens on valid or invalid shapes, what the return value looks like, or why several schema parameters are marked as discarded. This is too little context to guide a 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 short, but this is under-specification rather than effective conciseness. The two sentences omit the mapping to actual input parameters and the success/failure behavior, so they do not sufficiently inform an agent.

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 a seven-parameter schema, no annotations, and no output schema, the description is far from complete. It does not explain which parameter carries the Jira key, what a valid shape is, or what the tool returns, so an agent cannot safely 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?

The schema documents seven parameters with individual descriptions, but none of them is a 'key' and the description does not map any parameter to the Jira-key check. The mismatch between the 'key' concept and the provided ref/url/city/etc. parameters makes the parameter semantics more confusing rather than clearer.

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 verb and a resource ('Check a Jira issue key shape'), but it largely restates the tool name and introduces a 'key' that does not appear anywhere in the input schema. An agent cannot tell which input should be checked, so the purpose is not functionally clear despite the grammatical sentence.

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

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

No guidance is given on when to use this tool versus the many sibling shape/URL/domain checkers. There are no conditions, exclusions, or references to alternatives, so choosing this tool over siblings would have to be based on the name alone.

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

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

No annotations are present, so the description carries the full burden. 'Body discarded' is a useful behavioral hint, but it does not disclose network behavior, redirects, timeouts, error handling, side effects, or whether this is a safe read-only operation, leaving the agent underinformed.

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 a key behavioral note are front-loaded. 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 tool with 9 optional parameters, no annotations, no output schema, and many close siblings, this description is not complete enough to invoke correctly. It does not say which parameter(s) to use, what the status response looks like, or how to handle the unrelated schema properties.

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 an individual description. The tool description adds no parameter-level meaning and even conflicts with the `url` property's 'normalize or cite' purpose, but the schema itself is self-documenting.

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 output ('HTTP status') and a specific resource ('public library docs URL'), so it is more than a tautology. But the input schema exposes nine unrelated optional parameters (city, feed, json, zone, query, etc.), and the `url` parameter is described as 'normalize or cite' rather than a docs URL, making the stated purpose misleading. It also does not distinguish this from overlapping siblings such as fetch-status or browser-url-ok.

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

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

The description implies a use case for checking a public library docs URL, but it gives no when-to-use or when-not-to-use guidance. With numerous sibling URL/status tools (fetch-status, browser-url-ok, playwright-url-ok), an agent has no basis for choosing this one over them.

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

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

The phrase 'Values discarded' hints that the operation does not modify the input, but it does not explicitly state side-effect freedom, error behavior, or whether any external resources are accessed. The tool name suggests a memory-related function, but that is unexplored.

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 contains no fluff. It uses two short sentences, both of which add relevant information without redundancy.

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

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

The description provides insufficient context: it does not identify the input parameter, specify the return format (presumably an integer count), or clarify how the tool behaves with invalid JSON. Given the large parameter list and lack of output schema, an agent would struggle to call this tool correctly.

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

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

The schema descriptions are internally inconsistent with the stated purpose. For example, the 'json' parameter says 'validate' while the tool claims to 'count keys', and all parameters are described as 'discarded', implying they are ignored. No parameter is clearly designated as the JSON input, making the schema 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 clear action ('Count keys in a JSON object') but does not specify which parameter contains the JSON object, leaving the input ambiguous among the 9 parameters. The extra note 'Values discarded' adds context but does not resolve the mapping.

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

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

No usage guidance is provided. The description does not indicate when to prefer this tool over siblings like 'validate-json' or 'search-query-len', nor does it mention any conditions 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, the description carries the behavioral disclosure burden. It does disclose a key behavioral trait: 'Query and fragment are dropped,' which tells the agent not to expect those parts in the output. It does not describe side effects or error cases, but for a read-only normalization-style tool the main 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?

The description is two short sentences with no filler. The main output intent is front-loaded in the first sentence, and the single important behavioral nuance is in the second.

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 adequate for the core url parameter but not complete for the surrounding context: there is no output schema, no annotations, and the input schema contains 9 optional parameters. The description does not state the output shape or address the expected behavior when non-url parameters are supplied, leaving the agent to rely on parameter descriptions.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the tool description adds no parameter-level guidance. The description's mention of a URL aligns with the url parameter, but it does not explain which of the 9 optional parameters are relevant or confirm that the other parameters are ignored; the schema descriptions carry that weight.

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: 'Return origin, host, and path for a URL.' This clearly scopes the tool's output and differentiates it from URL-checking siblings like browser-url-ok or domain-shape, which validate or inspect shapes rather than normalize into components. The additional sentence about dropping query and fragment makes the purpose even more precise.

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

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

The description implies the intended use: call this when you need origin, host, or path extracted from a URL. However, it gives no explicit when-not-to-use guidance or alternative routing, even though the sibling list contains similar URL-related tools such as browser-url-ok and figma-url-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 that no browser is launched, which is a useful behavioral note. However, with no annotations provided, it fails to mention other side effects such as whether a network request is made, whether external services are contacted, or whether any state changes 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 concise and front-loaded, stating the primary purpose in the first sentence and the key safety/behavioral constraint in the second. Every word adds value, and there is no unnecessary elaboration.

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 lacks essential context: it does not specify the return value, how a successful or failed check is reported, whether network access is involved, or why many unrelated parameters exist in the schema. With no output schema and no annotations, this is insufficient for an agent to confidently use the tool.

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

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

The description only concerns checking a URL, but the input schema includes eight additional loosely related parameters (e.g., city, feed, json, zone) that are not explained in the description. Even the 'url' parameter's schema description says 'normalize or cite' rather than 'check if open,' making the parameter semantics misleading and confusing.

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

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

The description clearly states the tool checks whether a URL can be opened, and the phrase 'No browser is launched' helps distinguish it from browser-launching alternatives. It is concise and specific, though it does not detail what 'opened' means in terms of HTTP response or accessibility.

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 usage guidance is given. The description does not say when to prefer this tool over similar siblings like browser-url-ok or fetch-status, nor does it mention any prerequisites or conditions for use. The only hint is that no browser is launched, but this is not framed as a usage recommendation.

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 disclosure burden. The phrase 'Query discarded' is a useful side-effect disclosure, but it does not clarify whether any other supplied fields are ignored, whether the query is executed anywhere, or whether there are other behavioral implications beyond discarding the input.

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

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

The description is extremely concise: two short sentences with no filler. The primary action is front-loaded, and the side-effect 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?

No output schema and no required parameters create gaps: the description does not specify the return format of the count or confirm that `query` is the intended input. The large set of optional parameters is unacknowledged, though each schema entry helps clarify that the others are discarded.

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. The description adds no extra parameter semantics beyond loosely referring to 'a search query', which maps to the `query` parameter but provides no new insights.

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 resource ('characters in a search query'), clearly distinguishing this from sibling counting tools like hn-front-count and memory-key-count. It is not a tautology and leaves little doubt about the tool's 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 description implies usage: when an agent needs the character count of a search query, this is the tool. However, it offers no explicit guidance on when not to use it or which sibling alternatives might be more appropriate for related tasks.

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 only says 'Short catalog' and does not disclose whether the tool performs any checks, returns codes, accepts parameters meaningfully, or has side effects. This is too thin for a tool with seven input 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 a single, short, front-loaded phrase with no filler. It is efficient and easy to parse, although the brevity contributes to the lack of behavioral context.

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 unrelated-looking input parameters, no output schema, and no annotation support, the description is far from complete. An agent cannot tell how the catalog relates to parameters like 'city', 'json', or 'path', nor what the expected return value is.

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 schema coverage is high at 100%. The tool description adds no parameter-level meaning, but the schema itself documents each field, matching the baseline of 3 for well-covered schemas.

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

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

The description clearly identifies the resource: a catalog of common HTTP status codes. While it lacks an explicit verb like 'list' or 'return', the purpose is reasonably inferable and distinct from siblings focused on fetching or validation.

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

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

No guidance is provided about when to use this tool versus any sibling. There is no mention of alternatives, prerequisites, or context, leaving the agent to guess when a status-catalog lookup is the right call.

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 full burden of behavioral disclosure. It meaningfully discloses that the prompt/input is discarded, which is a notable behavioral trait, but it does not clarify side effects, return format, or the nature of the three-step template, 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 very concise: two short sentences with no filler, and the core purpose is front-loaded. While it is efficient, it is arguably terse enough that some useful context is missing, but this dimension focuses on conciseness, which is handled well.

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

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

Despite having seven input parameters and no output schema, the description does not explain why this tool exists, when to call it, what the template contains, or how the parameters relate to the output. The current text is too sparse to give an agent enough context to invoke it confidently in a real workflow.

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 have their own descriptions in the input schema, so the schema already defines parameter semantics. The description adds no new parameter-level information and merely echoes the discard behavior already indicated by each parameter's description, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb ('Return') and resource ('a three-step thinking template'), so an agent can tell that this tool produces a predefined template rather than performing analysis. It is clear, though it does not explicitly distinguish itself from sibling tools or explain what the template contains.

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

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

The description gives no explicit guidance on when to use this tool vs. alternatives. 'Prompt discarded' implies input is ignored, but there is no mention of use cases, exclusions, or comparisons with sibling tools, leaving the agent to infer when this template is 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?

No annotations are present, so the description carries the full burden of behavioral disclosure. It only says what the tool returns, but does not mention output format, error behavior, side effects, or that the many unrelated input fields are effectively ignored or 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 description is a single short sentence with no filler. It is front-loaded with the core action and resource, and every word contributes to the meaning.

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

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

With no output schema and no annotations, the description is too sparse. The input schema has nine optional parameters with zero required fields, and the description does not tell the agent which parameter to supply, what the response looks like, or that unrelated parameters are ignored.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description does not add meaning beyond the schema, nor does it clarify which parameter should be used for the timezone, though the schema's zone field aligns with the description.

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

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

The description states a specific action, retrieving the current time for a named IANA timezone, which is clear and not a tautology of the tool name. It does not explicitly name sibling alternatives like utc-time or iana-zones, but the IANA timezone qualifier helps distinguish the intended scope.

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

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

There is no guidance about when to use this tool versus alternatives such as utc-time or iana-zones, and no mention of prerequisites or typical use cases. The only usage signal is implied by the description itself, which is not enough to guide selection among similar time-related tools.

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

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

With no annotations, the description carries the full burden, but it only states the output and says nothing about the tool's unusual 9-parameter schema, that parameters are discarded, or what exact behavior to expect. It does not contradict annotations, but it is too thin to provide real 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 a single concise sentence and front-loads the key behavior without filler. It is slightly under-specified relative to the large input schema, but as a structure it is efficient and easy to parse.

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

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

There is no output schema, so the description should clarify whether the timestamp is ISO 8601, a Unix epoch, or another format. It also does not explain why the tool accepts nine unrelated optional parameters or that they are all discarded, leaving important gaps for an agent.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the tool description itself adds no parameter information. All parameters are optional and each has a schema description, but the description does not help an agent decide whether or why to pass any of them.

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

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

The description clearly identifies the tool as returning the current UTC timestamp, which is specific and understandable. It lacks an explicit verb and does not differentiate itself from sibling tools like timezone or iana-zones, so it does not reach a 5.

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

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

The phrase 'Current UTC timestamp' implies the tool should be used when the current UTC time is needed, but it offers no explicit when-to-use or when-not-to-use guidance. It does not name alternatives or explain how this differs from sibling time-related tools.

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

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

Annotations are absent, so the description carries the full burden, and it does contribute one genuine behavioral disclosure: 'The body is discarded' tells the agent the input is not retained and the call has no lasting side effect. But it stops there — it does not disclose return/error behavior, whether supplying url/feed/host triggers a network fetch, or what happens on invalid JSON. Useful but thin for an unannotated 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?

Two sentences, roughly thirteen words, zero filler, and the primary verb+object is front-loaded. The second sentence ('The body is discarded.') earns its place as the only behavioral information. The brevity is a mild net positive, though it is partly purchased by the under-specification 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 exposing nine parameters with no annotations and no output schema, a single line is not enough. The description never states what the tool returns (boolean? status code?), which parameter to use for raw JSON text versus a fetchable source, or how invalid JSON is reported. An agent cannot confidently construct a correct call from this definition alone.

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

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

All nine parameters have schema descriptions, so schema coverage is ~100% and the baseline of 3 applies. The description itself adds no parameter-level meaning — it never maps 'a body' to json versus path versus url. In fact, the schema's own parameter texts (e.g., city: 'City name for a public weather hint', ref: 'Git ref name') look recycled from sibling tools and actively muddy which parameter should carry the JSON.

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 object: 'Check whether a body is valid JSON.' That is an unambiguous statement of purpose. However, 'a body' is never tied to the seven heterogeneous parameters (ref, url, city, feed, host, json, path), and the description does not differentiate it from sibling validity-check tools (domain-shape, wiki-title-ok, file-path-ok), 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?

The description provides no guidance on when to use this tool versus alternatives or on how to select among parameters. An agent cannot tell whether validate-json is preferred over web-fetch, inspect-robots, or github-repo-shape for a given task, nor whether to pass raw text in 'json' versus a URL in 'url' or a path in 'path'. This is the 'no guidance' 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the external source (Open-Meteo) but does not explain side effects, output format, error behavior, or that the other eight schema parameters are ignored/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 description is a single concise sentence with no filler. It front-loads the core purpose and source, though it omits useful usage details that could make it more 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?

The tool is more complex than the description acknowledges: 9 optional parameters, no required fields, no output schema, and no annotations. The description does not explain which parameter to pass, what the response looks like, or why unrelated parameters are present, leaving significant gaps for an agent.

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 that 'city' is the key parameter, but it does not clarify why the schema also includes ref, url, feed, host, json, path, zone, and query, or how they relate to this weather tool.

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

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

The description states a clear purpose: returning the current temperature for a city via Open-Meteo. It is specific about the resource (city) and the data source, though it doesn't explicitly distinguish itself from sibling tools like geo-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?

The description implies when to use the tool: when a current city temperature is needed. However, it provides no explicit guidance about alternatives, exclusions, or which sibling tools might be more appropriate in other cases.

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

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

With no annotations, the description carries the behavioral disclosure burden. It does disclose a key behavioral trait: the body is discarded, so only status and content type are returned. However, it does not mention redirects, authentication, rate limits, or the fact that many of the schema fields appear to be discarded shape checks.

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 terse sentences with no filler. The core behavior is front-loaded, and the body-discard note is a useful secondary detail. 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?

Given no output schema, no annotations, nine optional parameters, and many sibling tools, the description is too sparse. An agent gets no help with return format, which parameter to pass, or when to prefer a sibling tool, leaving significant ambiguity.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds some meaning by implying that `url` is the central parameter and that the body is discarded, but it does not clarify why eight other optional parameters exist or how they relate to the tool's 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 clearly names the resource ('public URL') and the expected outcome ('HTTP status and content type'), and adds a meaningful constraint ('Body discarded'). It is not a tautology, though it lacks an explicit verb and does not differentiate itself from nearby siblings such as fetch-status.

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

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

No guidance is given about when to use web-fetch versus alternatives like fetch-status, browser-url-ok, or normalize-url. The phrase 'public URL' implies a scope restriction, but there is no explicit when-to-use or when-not-to-use 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 full burden of behavior disclosure. It only notes that the title is discarded, but omits whether a network request is made, whether the operation is read-only, and what a successful or unsuccessful result looks like.

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

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

The description is brief and contains no filler words. However, the second sentence adds only a narrow privacy detail and does not address critical operational information.

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

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

For a tool with no annotations and no output schema, this description is far too sparse. It fails to state which parameter to pass, what the return value is, or when to prefer this tool over siblings, leaving agents without essential call 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 description never identifies which schema parameter receives the Wikipedia title. The eight generic string parameters (ref, url, city, feed, host, json, path, query) all have unrelated descriptions, and none maps to a 'title'. An agent cannot determine how to populate the call, making the high schema coverage irrelevant.

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') and a clear resource ('whether a Wikipedia title exists'). It unambiguously distinguishes this tool from sibling validators that check URLs, file paths, or shapes.

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

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

The description offers no guidance on when to use this tool versus sibling validation tools. There are no mention of alternatives, exclusions, or context in which this check should be selected.

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