ISO country IO

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

With no annotations, the description carries the full disclosure burden and does meaningful work: it states the return payload, labels the service 'public pay-per-call' (signaling cost/access), and explicitly says task text is discarded. The read-only nature is inferable from 'Find' and 'Returns'. It omits details like auth or rate limits, but for a lookup-style tool the disclosed traits are substantive.

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 the action and resource first, followed by the return list and a key caveat. Every clause adds information and nothing is repeated from the schema. This is appropriately sized and well front-loaded.

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 exposes 9 heterogeneous optional parameters and no output schema, but the description never explains how those parameters relate to finding the gateway or which ones should be supplied. It does not say whether to call with no arguments or with a specific field, and it gives no call pattern. The schema notes describe individual parameter safety but not how to use them together, leaving the definition incomplete for confident invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. Each of the 9 parameters already has its own description, including discard/no-disk-access behavior. The tool description adds no per-parameter meaning beyond the schema; 'Task text discarded' is a general behavioral note rather than a parameter explanation.

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 verb and object: 'Find a public pay-per-call tool gateway (Monid)' and lists the outputs (CLI setup, how-it-works, skill file, remote MCP hops). This distinguishes it as an index/lookup tool rather than a validator like normalize-url or validate-json. It loses a point because 'Monid' and 'remote MCP hops' are unexplained jargon.

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: call this when the agent needs to locate/configure the Monid pay-per-call gateway, and 'Task text discarded' warns not to expect free-text task processing. However, no alternative sibling tools are named, and there is no explicit when-not-to-use guidance, so the usage context is only 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 provided, the description carries the full burden of behavioral disclosure. It does disclose that no browser is launched, which is valuable, but it does not explain whether a network request is made, whether the check is shape-only, what side effects exist, or what the return value looks like. The schema hints at 'discarded after the shape check,' but the description itself omits this important behavioral 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 very short and front-loaded: the core action appears in the first sentence, and the second sentence adds a meaningful qualification. There is no fluff or repetition, though the brevity does leave important gaps.

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

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

For a tool with 9 optional parameters, no annotations, no output schema, and many similar siblings, this description is incomplete. It does not explain return values, which parameter to use, whether the check is local or network-based, or how it differs from sibling tools. The agent would need to guess or inspect other tools to use 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 coverage is 100%, so the baseline is 3 and the schema does document all parameters. However, the description adds no clarification about which parameter is the primary URL to check, and the schema's own descriptions are tangential (e.g., 'HTTPS URL to normalize or cite' rather than 'URL to check'). An agent could infer the URL parameter, but the alignment between description and schema is weak.

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 verb ('Check') and resource ('whether a URL can be opened'), and adds a useful differentiating detail: 'No browser is launched.' However, it does not fully distinguish this tool from other URL-related siblings such as fetch-status or normalize-url, and 'can be opened' is ambiguous between syntactic validity and network reachability.

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

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

There is no guidance about when to use this tool versus alternatives. The sibling list contains several URL-related tools (fetch-status, normalize-url, web-fetch, playwright-url-ok), but the description never names them or explains the selection conditions. The only implied context is that no browser is launched, which is not enough 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, but it only says 'Expression discarded.' It does not explain what the tool returns, whether inputs are only shape-checked, how the nine schema properties are used, or what side effects exist. The single behavioral claim refers to an expression that is not present in the schema.

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

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

The description is short and front-loaded, with no wasted words. But this is under-specification rather than effective conciseness, because the two sentences omit essential information about the actual parameters and fail to clarify how the tool is meant to be invoked.

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 mentions a nonexistent expression and ignores every schema property, leaving an agent unable to know what inputs to provide or what result to expect. This is inadequate for a nine-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 schema already documents all nine parameters in detail. However, the description adds a phantom 'expression' concept that does not map to any schema property, and it provides no useful grouping or usage semantics for the actual parameters. It therefore undermines rather than clarifies parameter meaning.

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

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

The description states a specific operation, 'Evaluate a+b style arithmetic', which gives it a concrete verb and resource. However, the input schema contains no expression parameter at all; its fields are URLs, JSON, file paths, timezone names, and queries. This makes the stated purpose misleading and disconnected from the actual callable interface.

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

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

There is no guidance about when to use this tool versus any relevant sibling such as validate-json, domain-shape, or search-query-len. The description does not mention alternatives, exclusions, prerequisites, or contextual use cases, so an agent has no basis for selecting it correctly.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It does add one useful behavioral guarantee: 'Page content is not stored.' However, it does not disclose whether the URL is fetched, how redirects or errors are handled, or any other side effects, leaving most of the safety profile unstated.

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

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

The description is two short sentences with no filler. The primary behavior is front-loaded, and the privacy note earns its place. It is appropriately concise for the information 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?

The tool has nine parameters, no output schema, no annotations, and many overlapping siblings, yet the description only covers the URL case. It does not explain the role of the other parameters, what output format to expect, or how this tool fits among the sibling URL/status tools. This is insufficient context for an agent to reliably select and 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 input schema has high description coverage, so the baseline is 3. The description adds no parameter-level meaning beyond naming 'URL'; the schema already documents each parameter individually. The description does not help reconcile why the tool accepts many unrelated-looking parameters like ref, city, feed, and 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 action and outputs: 'Return host, scheme, and HTTP status for a URL.' This is clear and uses a specific verb and resource. However, it does not differentiate from closely related sibling tools like fetch-status or normalize-url, and the tool name 'citation' does not intuitively signal this 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 versus the many overlapping URL/status tools in the sibling list. There are no exclusions, prerequisites, or alternative tool names mentioned. An agent would have to guess whether to prefer citation over fetch-status or web-fetch.

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

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

No annotations are provided, so the description carries the transparency burden. It does add a meaningful privacy guarantee ('No identifiers are retained') and the schema reinforces that inputs are discarded. However, it does not disclose the output behavior, possible external calls, error cases, or 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 only two sentences, front-loaded with the main purpose and followed by a privacy note. There is no filler or repetition, though the extreme brevity contributes to the overall ambiguity.

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

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

With 9 optional parameters, no output schema, and no annotations, the description is too thin for reliable invocation. The agent is not told what a classification result contains, whether a single field or multiple fields should be passed, or how the result maps to the listed 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%, so the schema already describes every parameter, establishing the baseline at 3. The description adds no extra meaning about how ref, url, city, feed, host, json, path, zone, or query influence the classification.

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

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

The description states an action ('show how this request is classified') and a subject, so it is not a tautology. However, it never defines what 'classified' means, what categories or output the agent should expect, or how this tool relates to the many specialized 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 about when to use this tool instead of alternatives such as normalize-url, validate-json, timezone, or file-path-ok. The description does not say whether compatibility is a pre-routing step, a fallback, or a general classifier.

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

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

There are no annotations, so the description must carry the full behavioral burden. It discloses one boundary ('without WHOIS or ownership data') but does not state return format, side effects, failure behavior, or how the other schema parameters are handled. For a tool with no output schema, this is insufficient.

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

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

The single sentence is front-loaded and contains no filler, but it is underspecified for a tool with nine optional parameters, no required parameters, and no output schema. Conciseness has crossed into incompleteness.

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

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

Given the high parameter count, no annotations, and no output schema, the description is not complete enough. It only explains hostname splitting and leaves eight schema parameters effectively unexplained, plus it does not describe 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?

Schema description coverage is 100%, so the baseline is 3. The description reinforces that 'host' is the relevant input by mentioning hostname, but it adds no meaning for url, feed, json, path, zone, query, ref, or city, and does not clarify whether those are valid inputs or should be ignored.

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

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

The description uses a specific verb and resource: 'Split a hostname into labels' and adds a useful boundary with 'without WHOIS or ownership data'. It is clear about the core operation, but it does not differentiate among the many sibling shape/ok tools, and the nine-parameter schema makes the actual scope ambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives such as github-repo-shape, file-path-ok, or normalize-url. There is no mention of when-not-to-use, prerequisites, or which sibling tools are preferable for other input types.

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

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

With no annotations available, the description carries the transparency burden. It does disclose the HTTP method (HEAD) and the limited output (status only), which is helpful. However, it does not address redirect behavior, error handling, timeouts, or the fact that most of the declared parameters are discarded.

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

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

The description is a single, front-loaded sentence with no filler. It is easy to parse and communicates the core action efficiently, though it is perhaps too terse for the complexity implied by the 9-parameter 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 annotations, no output schema, and a 9-parameter input schema, this one-sentence description is not complete. It fails to explain why many parameters exist, what status values look like, or how errors and edge cases are handled, 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?

Although schema coverage is 100%, the description does not map its stated purpose to the correct parameter, and the schema's `url` description ('HTTPS URL to normalize or cite') conflicts with the HEAD-status purpose. The broad set of unrelated optional parameters further confuses which input actually drives 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 clearly states a specific action: issue a HEAD request to a public URL and return only the status. This is specific enough to convey the core operation, but it does not distinguish this tool from siblings like browser-url-ok, playwright-url-ok, or 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 on when to use fetch-status versus the many sibling URL/status tools. There are no alternatives, exclusions, or context clues beyond the bare operation, leaving the agent to infer the intended use case.

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

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

No annotations are provided, so the description carries the full disclosure burden. It reveals one behavior—'Path discarded'—but does not state whether the operation is read-only, what validation or extraction occurs, what happens with invalid input, or why multiple unrelated schema parameters are listed as 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 two short sentences with the main action front-loaded. It contains no filler words, but the second sentence, 'Path discarded,' is cryptic and sacrifices clarity for brevity.

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, many sibling tools, and a schema with several parameters, this description is too sparse. It does not explain the output format, the expected Figma URL format, or how an agent should treat the numerous discarded parameters, leaving significant ambiguity about how to invoke the tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3; the description does not need to restate parameter details. It adds little beyond the schema, and 'Path discarded' is largely redundant with the path parameter's schema description. It also fails to clarify that `url` is the parameter meant to carry the Figma URL.

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 object: parse a Figma file URL. It is not a tautology and clearly identifies the target resource. However, it does not say what the parse produces or explicitly distinguish this tool from sibling shape-checkers such as github-repo-shape or jira-key-shape.

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

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

The description gives no guidance on when to use this tool versus alternatives like normalize-url, file-path-ok, or the other *-shape tools. There are no exclusions or decision rules, so the agent must infer selection primarily from 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 provided, the description carries the behavioral disclosure burden. 'No disk access' is a clear non-destructive guarantee and 'looks safe' signals the check is not authoritative. It could also mention return behavior or error handling, but the key safety trait is explicitly 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 clauses with no filler: it states the action, the object, and the critical behavioral caveat. Both sentences earn their place and the purpose is front-loaded.

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

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

The tool has no output schema, no annotations, and nine optional parameters, yet the description does not explain what 'safe' means, what the return value looks like, or how to select the relevant parameter. The schema helps with parameter documentation, but the description leaves too much unsaid for a tool in a crowded sibling group.

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 all parameters already have documented meanings in the input schema. The tool description adds no parameter-level detail beyond naming 'path', but the schema already compensates adequately.

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 path looks safe and explicitly notes there is no disk access. It distinguishes itself from URL-focused siblings by focusing on 'path', though 'safe' is left informal and undefined.

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

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

The phrase 'No disk access' implies this is for a purely lexical/shape safety check rather than filesystem verification, giving a weak usage boundary. However, it does not name alternatives like browser-url-ok or any explicit when-to-use/when-not-to-use 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?

With no annotations, the description carries the full burden of behavioral disclosure. It reveals only that Open-Meteo is the source; it does not describe return format, error behavior, whether inputs are discarded, rate limits, or side effects. 'Latitude and longitude' is an output statement, not a behavioral one.

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, making it quick to scan. However, it is too terse to compensate for missing usage and parameter 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?

For a tool with nine parameters, no annotations, no output schema, and many similar siblings, a one-sentence outcome statement is under-specified. An agent cannot confidently determine the input parameter, the output shape, or when to choose this tool over alternatives.

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

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

Although the schema has 100% description coverage, the tool description does not map 'a place' to any parameter. The only plausible parameter, city, is described in the schema as 'for a public weather hint; discarded after the call', which is ambiguous alongside this description. An agent cannot tell which of the nine properties 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 states a clear outcome: latitude and longitude for a place, sourced from Open-Meteo. It is more specific than the tool name and conveys the core function, though it does not explicitly name the expected input or differentiate it from weather-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?

There is no guidance about when to use geo-hint versus weather-hint, timezone, iana-zones, or other sibling tools. The description gives no prerequisites, alternatives, or conditions, so an agent must infer usage from the name and schema.

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. 'Parse' implies a pure extraction operation and the expected result is stated, but the description does not address invalid/non-GitHub URLs, accepted URL forms, or the exact return format.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to the agent's understanding of what the tool does.

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 purpose is clear, but with no output schema, no annotations, and nine optional parameters, the description should more explicitly indicate which parameter to pass and what the tool returns or how it behaves on failure. These gaps make it adequate but incomplete.

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

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

Schema description coverage is 100%, so the baseline is 3. The schema already explains that several parameters are discarded and that url is an HTTPS URL; the tool description adds no direct parameter mapping beyond identifying the GitHub URL as the source.

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

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

The description uses a specific verb and resource: 'Parse owner and repo from a GitHub URL.' This clearly states the transformation and differentiates the tool from sibling shape tools like domain-shape, figma-url-shape, and jira-key-shape.

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

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

The description establishes a clear usage context: use when a GitHub URL needs to be parsed into owner and repo. It does not explicitly name alternatives or state when not to use the tool, so it falls short of a 5.

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 behavioral disclosure burden. It does disclose that titles are discarded, which is a useful trait. However, it does not say whether the tool performs a network fetch, whether the parameters are effectively ignored, what the output type is, or how failures are surfaced.

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 clarifying caveat about titles follows immediately.

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

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

The description gives the essential count behavior and the title caveat, but with no annotations and no output schema it leaves the return shape and network behavior unspecified. For a simple count tool the gaps are moderate rather than fatal.

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, giving 100% schema coverage, so the baseline is 3. The description adds no per-parameter meaning beyond restating the 'titles discarded' caveat already present on the feed parameter. This is acceptable 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 states a precise verb and resource: 'Count current Hacker News front-page stories.' The added 'Titles discarded' makes clear this is a count-only tool and separates it from any title-returning or listing tool. No sibling tool overlaps with this exact purpose.

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

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

There is no explicit guidance about when to use this tool versus alternatives such as web-fetch or fetch-status. The only usage signal is implied by the purpose; no exclusions, prerequisites, or fallback 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, the description must carry the behavioral burden, but it only hints that this is a static collection of timezone names. It does not disclose whether the tool is read-only, what it returns, how invalid input is handled, or why the nine schema parameters are accepted/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 short, but it is an under-specified fragment rather than a well-structured definition. It lacks a verb and conveys so little information that the brevity reads as under-specification, not effective 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?

Given nine optional parameters, no output schema, and no annotations, a one-fragment description is not enough. An agent cannot tell what output to expect, what the parameters do, or how this relates to the sibling 'timezone' and 'utc-time' 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 description coverage is 100%, so the baseline is 3 even though the description adds no parameter-level meaning. The param descriptions are individually present but do not establish how parameters such as 'ref' or 'city' relate to IANA timezone names.

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 rather than an action: 'Common IANA timezone names for clock calls' restates the tool name and never says whether the tool returns a list, validates a name, or checks membership. It adds only a vague usage context ('clock calls') and fails to describe an operation.

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' gives an implied context for when the tool might be useful, suggesting it supplies timezone names for clock-related siblings such as timezone or utc-time. However, it does not explicitly state when to prefer this tool over alternatives or when not to use it.

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

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

With no annotations, the description bears the full burden of behavioral disclosure. It states the tool fetches public content and returns only counts, but it does not explain error behavior, rate limits, redirects, or how input parameters are treated beyond the schema's 'discarded after' notes.

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. 'Fetch a public robots.txt and return group counts only' efficiently conveys the core action and output constraint.

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

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

The tool has no output schema and no annotations, yet the description does not explain how to specify the target site, what 'group counts' means, or what the response shape is. The schema lists many optional parameters but none are clearly mapped to the robots.txt fetch behavior.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the tool description itself adds no parameter-level meaning. However, the schema descriptions are generic and do not clearly indicate which parameter selects the robots.txt URL, so the description does not compensate.

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 verb and resource: fetch a public robots.txt and return group counts only. It clearly distinguishes this from general fetch tools like web-fetch, though it does not explicitly name sibling alternatives.

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

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

The description gives no guidance on when to use this tool versus siblings such as web-fetch, fetch-status, or domain-shape. There are no exclusions, prerequisites, or alternative suggestions.

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 that the key is discarded, which is useful, but it does not state what the tool returns (boolean, normalized value, error), what shape rules apply, or any other behavioral side effects. This is insufficient for an agent to understand the tool's full 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 very concise and front-loaded with the main action: 'Check a Jira issue key shape.' Both sentences are short and avoid filler, though the description under-specifies critical input mapping.

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 annotations, and no output schema, the description is not complete enough for correct invocation. It does not identify which parameter to use, does not describe the expected return value, and only vaguely explains the discard behavior. An agent would likely need to guess among the 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 coverage is 100%, so a baseline of 3 would normally apply, but the description adds nothing about parameters and fails to map the 'Jira issue key' to any of the nine schema properties. The closest candidate, 'ref', is described as a Git ref name, not a Jira key, leaving the agent unable to determine which parameter 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 states a specific action and resource: check the shape of a Jira issue key, and it differentiates from sibling shape-checking tools by naming Jira explicitly. However, it does not indicate which input schema parameter should carry the Jira key, and the schema contains no property literally named 'key'.

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 Jira-specific wording implies when the tool should be used, but there is no explicit guidance about when to choose it over sibling shape-check tools, nor any exclusions or alternatives. The usage context is reasonably clear but not fully specified.

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 transparency burden. It does disclose that the body is discarded, which is useful, but it omits whether a network request is made, how redirects or errors are handled, and any rate-limit or auth considerations. This is thin for a network-facing 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?

The description is a single front-loaded sentence with no filler. It is concise and easy to parse, though it may be too terse for the complexity of the 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?

The tool has nine optional parameters, no required fields, no output schema, and no annotations. The description does not explain which parameter an agent should populate for a library-docs URL, how the status result is returned, or how the unrelated-looking parameters fit in. The rich schema prevents a score of 1, but critical selection context is missing.

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

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

Schema description coverage is 100%, and the schema already explains each parameter, including which values are discarded. The description adds little parameter-level meaning beyond the body-discard note, so the baseline of 3 applies.

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

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

The description states that the tool returns an HTTP status for a public library docs URL and that the body is discarded, so an agent can infer the basic operation. However, it never says which of the nine parameters to use, and it does not distinguish this tool from sibling tools like fetch-status, browser-url-ok, or 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?

There is no guidance about when to use this tool versus alternatives. The description is only a bare behavior statement and does not mention exclusions, preferred conditions, or sibling tools.

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

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

With no annotations, the description does disclose one meaningful behavioral trait: values are discarded and therefore irrelevant. However, it does not clarify whether keys are counted recursively or only at the top level, what happens for invalid or non-object JSON, or whether any state is retained.

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: the action and resource come first, and the key behavioral qualifier follows immediately. 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?

With no annotations, no output schema, and nine parameters, this one-line description is not enough for reliable tool invocation. Missing details include which parameter to populate, what the count applies to, and what return value or error behavior to expect.

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 of 3 applies even though the tool description itself adds no parameter-level meaning. The description does not identify which parameter should contain the JSON object, and the schema's wording for `json` is framed around validation rather than key counting.

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

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

The description states a highly specific operation: count keys in a JSON object, with the behavioral qualifier that values are discarded. This clearly separates it from value-inspecting or validation siblings like validate-json.

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

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

No guidance is given about when to use this tool over alternatives, and no sibling tools are referenced. There is no mention of conditions, exclusions, or how this differs from similar JSON-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 must disclose edge behavior itself, but it only mentions query/fragment dropping. It does not state whether this is a pure string operation, how invalid URLs are handled, or that the schema's host/path inputs are not the output fields described.

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 with no filler; the return value is front-loaded and the drop behavior is stated immediately. Every sentence earns its place.

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

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

For a tool with 9 optional parameters, no annotations, and no output schema, this one-line description is incomplete. The agent cannot determine the call shape beyond passing url, what the exact return structure is, or how the other parameters are treated.

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

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

Although schema coverage is 100%, the description creates terminological confusion: 'query' in the description refers to a URL component, while the schema's query parameter is 'Search text; discarded after the length check'. The description also fails to clarify that url is the relevant input and how host/path params relate to the stated outputs.

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 identifies a specific verb and resource: returning origin, host, and path for a URL, with query and fragment dropped. This is clear but it doesn't differentiate from sibling URL/shape tools such as 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?

Usage is implied: call this when you need a URL's origin, host, and path without query/fragment. There is no explicit when-not or alternative routing, and the description doesn't explain how the many optional schema parameters relate to this use.

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

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

With no annotations, the description carries the full burden of disclosing behavior. It does disclose one important trait, 'No browser is launched,' but it remains silent on whether network access occurs, whether the operation is read-only, what a successful check returns, or how the many discarded parameters factor into behavior. This is insufficient for a tool with no annotation safety signals.

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

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

The description is two short sentences, front-loads the primary purpose, and contains no filler. Every word contributes either to explaining what the tool checks or to an important behavioral caveat about not launching a browser.

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

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

Given 9 optional parameters, 26 sibling tools, no annotations, and no output schema, this description is far too thin to fully orient an agent. It explains neither how the unrelated optional parameters (city, json, zone, query) relate to checking a URL nor what output or side effects to expect.

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 of the 9 parameters is individually documented in the input schema. The tool description itself adds no parameter-level meaning, but per the baseline for complete schema coverage, a 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 clear action and resource: 'Check whether a URL can be opened.' It also adds a distinguishing negative trait, 'No browser is launched,' which helps separate it from browser-related siblings like browser-url-ok. However, it does not define what 'opened' means operationally, leaving some ambiguity about whether this is a syntactic, DNS, or HTTP-level check.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives. 'No browser is launched' hints at a lightweight or safe-check purpose, but it never names sibling tools or conditions such as 'use this instead of browser-url-ok when you want to avoid launching a browser.'

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 usefully say 'Query discarded,' indicating the query is not retained, but it does not disclose the return format, whether other parameters are ignored, or any side effects. The schema includes many unrelated-looking parameters, and the description does not resolve the 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 very concise and front-loaded: 'Count characters in a search query' immediately conveys the core action. Every sentence has some purpose, though the brevity contributes to under-specification 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?

Given nine optional parameters, no annotations, and no output schema, the description is not complete enough for reliable invocation. It fails to state the return value, which parameter to use, or that the other parameters are irrelevant. An agent would struggle to know what result to expect or why the other parameters exist.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add much beyond the schema, but the query parameter's own schema description ('Search text; discarded after the length check') aligns with the tool description, giving an agent a reasonable path to the relevant parameter. Still, the nine-parameter surface is left unclarified.

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

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

The description states a specific verb and resource: count characters in a search query. It is not a tautology and is distinguishable from siblings like memory-key-count or hn-front-count, though it does not explicitly differentiate itself or specify which parameter is the query.

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. It does not mention prerequisites, exclusions, or contexts, and none of the sibling tools are referenced. 'Query discarded' is a behavioral note, not usage 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?

No annotations are present, so the description carries the full burden of behavioral disclosure. It does not mention that parameter values are discarded, whether the tool is read-only, what side effects exist, or any network or auth implications. The single sentence offers no behavioral insight beyond the word 'catalog'.

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 avoids verbosity, but it is a fragment ('Short catalog of common HTTP status codes') rather than a complete sentence. It under-specifies the tool's purpose and behavior, so this is under-specification rather than effective 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?

The tool has seven parameters and no output schema, yet the description is a bare noun phrase. There is no explanation of how the parameters relate to the catalog, what the catalog contains, or what output format to expect. This is far too incomplete for an agent 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?

The description mentions none of the seven parameters. However, the input schema provides a description for each parameter, giving roughly 100% schema coverage. Therefore the baseline of 3 is appropriate even though the description itself adds no parameter semantics.

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 ('Short catalog of common HTTP status codes') rather than an action statement. It names the resource but does not state what the tool actually does with inputs like url, json, or host, so an agent cannot tell whether it returns a static list, filters by input, or performs some check. It also does not differentiate it from sibling tools like fetch-status or 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?

No guidance is provided about when to use this tool or when to choose an alternative. The description and schema offer no context for selecting this catalog over sibling tools such as fetch-status, domain-shape, or validate-json, leaving the decision entirely to the agent.

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 does disclose a key behavioral trait: the prompt is discarded rather than processed. However, it does not clarify whether all parameters are ignored, whether the template is static, or what the exact return content 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 very short and front-loaded: the main action appears first and every sentence earns its place. It is not padded, though the phrase 'Prompt discarded' is slightly cryptic and could be more explicit.

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 and no output schema, the description is too thin for a tool with nine optional parameters and many siblings. It does not explain what the three-step template contains, which parameters are relevant, or how this tool fits alongside the URL/validation-oriented siblings. Calling with no arguments is possible, but the surrounding context is missing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no additional parameter meaning; all nine parameters are already individually described in the schema, and many are explicitly marked as discarded.

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 verb and resource: 'Return a three-step thinking template.' It also warns that the prompt is discarded, which clearly separates this from tools that process input. It does not explain what the three steps are, but the core purpose is unambiguous.

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

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

There is no guidance about when to use this tool versus any alternative. 'Prompt discarded' implies it should not be used for actual reasoning, but no alternative is named and no use case is described.

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 core operation and gives no information about output format, response structure, or how the tool behaves with inputs. The schema parameter descriptions that mention discarding values are not part of the description and appear unrelated to timezone 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 a single, directly worded sentence with no filler or redundancy. It could be slightly expanded with parameter mapping, but that is a completeness concern rather than a conciseness flaw.

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 and no output schema, the description is too sparse to support correct invocation. The core input concept is missing from the schema, and no return or usage details are provided, leaving a critical gap for an agent trying to call this tool.

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

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

Although schema description coverage is 100%, the listed parameters (ref, url, city, feed, host, json, path, query) do not include any field corresponding to an IANA timezone. The description never maps its central concept to a specific parameter, so an agent cannot determine how to pass the required timezone.

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

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

The description clearly states the tool's function: returning the current time for a named IANA timezone. It is specific about the resource and action, though it does not differentiate itself from sibling tools like utc-time or iana-zones.

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

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

The description implies when to use the tool: when you need the current time in a named IANA timezone. However, it provides no explicit guidance on when not to use it or which alternatives might be more appropriate.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the output is the current UTC timestamp and does not mention side effects, return format, network access, or the role of the input parameters, leaving the tool's behavior underspecified.

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: 'Current UTC timestamp.' is immediately clear and wastes no words. However, it is arguably too minimal for a tool whose schema includes seven unrelated parameters, so it earns a 4 rather than a 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?

The tool has no output schema and no annotations, and the description does not explain the timestamp format, whether parameters are ignored, or how this differs from 'timezone.' Given the complexity introduced by the schema, the description is not complete enough for an agent to confidently invoke the tool in all 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 already provides descriptions for all seven parameters, so the high schema coverage sets a baseline of 3. The description adds no parameter meaning, and the parameter descriptions themselves reference concepts like 'shape check' and 'weather hint' that are not explained in the tool description, but the schema still 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 'Current UTC timestamp.' clearly states the tool returns the current UTC time. It is understandable on its own, though it does not explicitly differentiate itself from the sibling 'timezone' tool, and the presence of seven unrelated parameters in the schema slightly muddies the core 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?

The description gives no guidance about when to use this tool versus alternatives like 'timezone' or other sibling tools. There are no usage conditions, exclusions, or references to alternative tools, so the agent is left to infer the intended 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 that the body is discarded, which is a useful behavioral detail. However, with no annotations available, it does not state the return type or any other side effects, leaving the agent to guess the tool's output shape.

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

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

The description is exactly two short sentences with no filler. The core action comes first, followed by the key behavioral caveat, making it highly scannable for 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?

The description leaves out the return value (no output schema exists) and does not explain the many seemingly unrelated parameters in the schema. An agent is forced to infer that 'body' maps to the 'json' parameter, which is a meaningful gap for a tool that should be self-explanatory.

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 a description for every parameter, including 'json' as 'JSON text to validate; discarded after the check', so coverage is high. The description itself adds no parameter-specific meaning beyond the schema and does not tie 'body' to the 'json' parameter.

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

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

The description states a specific action ('Check whether a body is valid JSON') with a clear verb and resource. It is distinguishable from sibling tools by its JSON focus. However, 'body' is vague compared to the schema's 'json' parameter, 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 description gives no guidance about when to use this tool versus alternatives, no prerequisites, and no exclusions. It does not even clarify which parameter should carry the JSON, relying entirely on the schema.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It only states the data source and result category, but does not mention whether the operation is read-only, calls an external API, has rate limits, or how errors are handled. The schema hints that many parameters are discarded, but the description itself adds little behavioral 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 concise and front-loaded, with no wasted words. It could be slightly more informative given the unusual nine-parameter schema, but as a one-line purpose statement 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?

This tool has nine parameters, no annotations, and no output schema, so the description needs to compensate by explaining return values, which parameters matter, and expected behavior. The single sentence does not cover these, leaving the agent uncertain about the response format and the purpose of the many unrelated-looking parameters.

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

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

Schema description coverage is 100%, so the schema already provides detailed meaning for all parameters. The description adds 'for a city' and 'via Open-Meteo,' which helps orient the agent, but it does not add parameter-level semantics beyond what the schema already states.

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 purpose: retrieving the current temperature for a city using Open-Meteo. It is specific enough about the resource and data source, though it uses a noun phrase rather than an explicit verb and does not directly distinguish itself from sibling hint 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 explicit guidance about when to use this tool versus the many sibling tools listed. The phrase 'for a city' implies a weather lookup, but the description does not clarify which of the nine input parameters should be used, which are irrelevant, or when an alternative tool would be more appropriate.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does disclose two important traits: it only targets public URLs and discards the response body, which helps prevent misuse. But it omits other relevant behaviors such as redirect handling, timeouts, failure responses, and whether any content is retained beyond the status/content-type extraction.

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 compact: two short sentences that front-load the core result and then add a material caveat. There is no filler or repetition of the tool name, and every word contributes to agent understanding.

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 small description, the tool is complex: nine optional parameters, no annotations, no output schema, and many near-sibling tools. The description does not explain which parameters are relevant, what the return value looks like, or how this differs from fetch-status and browser-url-ok, so an agent could easily misuse or overlook it.

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

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

Schema description coverage is 100%, so the baseline is 3 even without parameter details in the description. The description adds no per-parameter meaning beyond the schema. Notably, the schema lists nine highly varied optional parameters including city, feed, json, and query, while the description only mentions URL; this mismatch is not resolved but is not a direct contradiction.

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

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

The description names a specific operation and resource: it returns HTTP status and content type for a public URL. It also adds the key clarifying detail that the body is discarded. However, it does not distinguish web-fetch from close siblings like fetch-status or browser-url-ok, so it stops just short of full differentiation.

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

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

The description implies use for checking HTTP status and content type, but it gives no explicit guidance about when to choose this tool over siblings such as fetch-status, browser-url-ok, normalize-url, or inspect-robots. There are no exclusions or alternative routing cues, so an agent has to infer the right tool from 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?

With no annotations present, the description carries the disclosure burden. It discloses that the title is discarded after the call, a useful data-retention note, but it does not state whether this is a remote lookup, whether it is read-only, or what response is returned.

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 the core action front-loaded and no filler. Every sentence adds information: the purpose and the post-call disposal behavior.

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 seven parameters and no output schema or annotations, the description is insufficient. The missing parameter mapping is critical, and the lack of any note about the return value or failure behavior leaves the calling contract under-specified.

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

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

Although the schema documents all seven parameters, the description introduces a 'title' input that does not appear in the schema and never maps the title to a specific property. The parameter descriptions are generic and do not clarify which parameter represents the Wikipedia title, so the agent cannot reliably decide what to pass.

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

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

The description states a specific verb and resource: checking whether a Wikipedia title exists. It is recognizable as distinct from siblings like fetch-status and normalize-url, though it does not explicitly differentiate itself or say which input carries the title.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusion conditions. The description only states the action and leaves all selection logic to the agent.

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