America/Kentucky/Louisville clock

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint, and sideEffectsHint, so the safety profile is covered. The description adds the useful behavioral detail that task text is discarded and lists output artifacts, but it does not address failures, auth, or parameter handling beyond that.

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 redundant filler. It communicates purpose, outputs, and a behavioral caveat efficiently, though the unexplained 'Monid' term slightly reduces clarity.

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 low-complexity tool with no output schema, the description lists the main returned artifacts and notes discarded task text. However, it does not explain what 'Monid' is, how the parameters relate to the gateway search, or when this tool should be preferred over similar siblings.

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

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

The input schema has 100% description coverage, with each parameter carrying a note such as 'discarded after the shape check.' The tool description does not add parameter-level meaning beyond the schema, so the baseline 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 names a specific action ('Find') and a specific resource ('public pay-per-call tool gateway (Monid)'), and lists what it returns. It is clear enough, though 'Monid' and 'tool gateway' are unexplained jargon and it does not explicitly distinguish itself from the many sibling tools.

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

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

There is no explicit guidance about when to use this tool versus alternatives. The phrasing implies it is for finding a Monid gateway, but no sibling alternatives are named and no when-not-to-use context is provided.

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

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

No annotations are present, so the description carries the full burden. It discloses only that no browser is launched, but does not mention whether a network request is made, whether the check is read-only, what 'can be opened' means, or how results are returned. This is insufficient for a tool with no annotation safety profile.

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

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

The description is a single, front-loaded sentence with no wasted words, and the critical behavioral note is included. However, for a tool with 9 parameters and many siblings, the brevity leaves important context unstated.

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 annotations, no output schema, and a large sibling list, the description is too thin. It does not explain how to invoke the check, what the result looks like, which parameters are relevant, or how it relates to fetch-status and playwright-url-ok.

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 documents each parameter, providing the baseline of 3. The tool description adds no parameter-level meaning and does not clarify which of the 9 unrelated optional parameters is central to the 'URL can be opened' check.

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

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

The description clearly states the action ('Check whether a URL can be opened') and the resource (URL), and adds a distinguishing behavioral note ('No browser is launched') that separates it from playwright-url-ok. It does not explicitly differentiate it from fetch-status or normalize-url, but the core purpose is clear.

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

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

There is no guidance about when to use this tool versus alternatives like fetch-status, playwright-url-ok, or normalize-url. The phrase 'No browser is launched' implies a lightweight check, but no explicit when-to-use or when-not-to-use context is provided.

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

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

No annotations are provided, and the description does not state whether the tool is read-only, whether it has side effects, what it returns, or what 'Expression discarded' means. The repeated 'discarded after...' phrases on parameters imply no persistence, but this is never clearly 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 extremely short, but brevity is not effective here because it omits essential details and contradicts the parameter schema. A few extra sentences clarifying the actual role of these parameters would be more useful than the current two-sentence text.

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 required fields, no output schema, and no additional context. The description does not explain why these parameters exist, what the tool actually does with them, what result format is expected, or what error conditions may occur. It is far from complete for an agent to use reliably.

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 covers 100% of parameters with descriptions, the parameter set is entirely mismatched with the stated arithmetic purpose. There is no 'expression' or 'a'/'b' parameter, and the given parameters (url, city, path, etc.) appear borrowed from other tools. Individually they are described, but collectively they do not support the described operation.

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 none of the nine parameters represent an arithmetic expression. All parameters are named ref, url, city, feed, host, json, path, zone, query, which have no apparent relation to computing a+b. The intended purpose is therefore confusing and internally inconsistent.

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. The sibling tools include timezone, URL, JSON, and search-related tools, but there is no indication of how calc-eval relates to them or what scenarios call for arithmetic evaluation.

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

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

With no annotations, the description carries the behavioral burden and does add one useful disclosure: 'Page content is not stored.' However, it does not mention network behavior, authentication, rate limits, or whether the many optional parameters are ignored, leaving the behavioral contract only partially transparent.

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

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

Two short sentences communicate the core function and the key privacy caveat with no filler. All included text 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?

Despite nine parameters, no output schema, no annotations, and many sibling tools, the description is only two sentences. It does not explain how the broad parameter set relates to the promised URL result, nor does it help an agent choose this tool over nearby 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 of 3 applies. The tool description adds no parameter-level meaning beyond mentioning a URL; the schema's per-parameter descriptions already document the discard behavior.

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

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

The description names a concrete output: host, scheme, and HTTP status for a URL, which is a specific verb/resource pairing. It does not distinguish this tool from siblings like fetch-status or normalize-url, so it is clear but not sibling-differentiated.

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

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

There is no guidance about when to choose citation over related tools such as fetch-status, normalize-url, web-fetch, or status-catalog. No when-to-use, when-not-to-use, or alternative-selection cues 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 carries the burden of behavioral disclosure. It does add one useful privacy behavior: 'No identifiers are retained.' However, it does not explain what the tool actually does with the various inputs, whether it performs network calls, what it returns, or what side effects exist beyond discarding data.

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

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

The description is just two short sentences with no filler. The privacy statement is concise and valuable. However, the extreme brevity likely comes at the cost of necessary detail, making it concise but not fully informative.

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 seven heterogeneous input parameters, no annotations, no output schema, and many closely related sibling tools. The description explains neither the classification semantics nor the return shape, so an agent has almost no basis for knowing what 'compatibility' means or 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?

The input schema already describes each of the seven parameters in detail, including discard behavior for several, so schema coverage is high. The description adds no parameter-level meaning, but it also does not need to compensate for a coverage gap. Baseline 3 is appropriate.

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

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

The description says 'Show how this request is classified' but never defines what classification means, what categories exist, or what output is produced. It reads more like a restatement of the tool name 'compatibility' than a clear definition, and it does nothing to distinguish itself from siblings like validate-json, normalize-url, or 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?

There is no guidance about when to call this tool instead of any of the many sibling tools that inspect URLs, JSON, paths, hosts, or weather hints. The only extra sentence is about identifier retention, not usage context or alternatives.

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

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

The description does disclose a useful behavioral boundary: it only splits labels and deliberately excludes WHOIS or ownership data. Because annotations are absent and there is no output schema, it still fails to disclose what the tool returns, whether it performs any network access, or what happens when inputs are invalid.

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 repeated schema information. Every word adds meaning: the verb, the resource, and the explicit exclusion of WHOIS/ownership data.

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 seven-property input schema, no output schema, and no annotations, this one-sentence description leaves too much unstated. An agent cannot tell whether host is required, what the output shape looks like, or what role the other schema fields play, so the tool is not fully specified for reliable 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?

All seven parameters already have descriptions in the input schema, so the baseline is 3. The tool description reinforces that 'host' represents the hostname to split, but it adds no meaning for the other six parameters (ref, url, city, feed, json, path) and does not clarify whether they are relevant to 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 states a specific operation—'Split a hostname into labels'—with a clear resource and a negative scope ('without WHOIS or ownership data') that prevents confusion with ownership-enrichment tools. It does not fully distinguish itself from sibling shape tools, and the one-line purpose does not explain the broad input schema that includes city, json, path, and other unrelated-looking fields.

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

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

The description implies the intended use case: an agent should call this when it needs hostname label splitting and does not need WHOIS/ownership enrichment. However, it offers no explicit guidance on when not to use it, no alternatives, and no comparison to siblings like normalize-url, web-fetch, or other shape tools.

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

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

With zero annotations, the description carries the full behavioral burden. 'HEAD' and 'return status only' disclose the HTTP method and output scope, which is useful, but the description doesn't say inputs are discarded, no body is fetched, how errors or non-2xx responses surface, or what the status return actually 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 single sentence is efficient and front-loaded with the verb, with zero padding. But at 8 words it underspecifies a tool with 9 parameters, no annotations, and no output schema — this reads as under-specification rather than disciplined 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?

For a 9-parameter tool with no annotations and no output schema, one sentence is insufficient. It never explains what 'status' means (HTTP status code?), what happens with the extra parameters, or what a successful or failed invocation 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 all 9 parameters are already documented in the schema with per-parameter details. The description adds no parameter-level meaning, matching the baseline of 3 for high schema coverage.

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

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

The description names a specific verb (HEAD), a resource (a public URL), and the outcome (status only), making the core purpose unambiguous. However, it doesn't reconcile with the 9-parameter schema that accepts unrelated inputs like city, json, and timezone, and it doesn't differentiate from siblings like 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?

No guidance on when to use this tool versus alternatives such as web-fetch, normalize-url, or browser-url-ok. The description states only what it does, not when to prefer it, and nothing about exclusions or non-goals.

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 mentions that the path is discarded, which hints at read-only normalization, but it does not state whether the tool is side-effect-free, what it returns, or any error conditions. This lack of explicit behavioral detail is a significant gap.

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

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

The description is extremely concise—two short sentences with no redundancy or filler. It front-loads the primary action and immediately clarifies a key behavior (path discarded), making it efficient for an agent 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?

Despite having 9 optional parameters and no output schema, the description provides almost no overarching context. It does not explain how parameters relate to the parsing task, what the returned result looks like, or what 'parse' means in this specific tool. The tool is complex enough that this sparse description leaves the agent largely uninformed about the full 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?

The schema already provides 100% parameter descriptions, so the baseline is 3. The description's 'Path discarded' adds a small detail about how the URL path is treated, but it does not meaningfully enhance understanding of the other 8 parameters or their interplay. Since the schema covers most semantics, the description adds only marginal value.

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

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

The description clearly states the action ('Parse') and the specific resource ('a Figma file URL'), so an agent can understand the basic purpose. However, it does not specify what the parsing produces or the outcome, leaving some ambiguity about the tool's exact 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?

There is no guidance on when to use this tool versus the many sibling tools (e.g., normalize-url, fetch-status, browser-url-ok). The description does not mention any context, prerequisites, or alternative tools, leaving the agent without direction on appropriate invocation.

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, and 'No disk access' is a meaningful behavioral disclosure that tells the agent the call has no filesystem side effects. 'Looks safe' also signals a shape/heuristic check rather than a guarantee about actual file security, though the exact safety criteria are not disclosed.

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 the essential purpose and side-effect profile front-loaded. Every word earns its place, and there is no redundant restatement of the tool name or title.

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?

Adequate for a simple validator, but gaps remain: there is no output schema, and the description does not state the return format or what 'safe' means. The schema's 'required: 0' and unrelated optional properties also make it unclear that a path argument is expected.

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 met: the schema already documents each parameter, including 'File path to check'. The description does not add parameter-level detail, and with 9 optional parameters it fails to clarify that 'path' is the relevant one for this tool, leaving some ambiguity.

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

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

The description names a specific operation ('check whether a path looks safe') and adds a key clarifying detail that the check is purely syntactic ('No disk access'). It differentiates from URL, title, and key validators by focusing on 'path', though it does not explicitly name an alternative or define what 'safe' means.

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 prefer this tool over sibling validators such as url-ok, wiki-title-ok, or jira-key-shape. The only implicit cue is the word 'path', which leaves the agent to infer the boundary of the tool without any explicit when-to-use or when-not-to-use direction.

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

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

With no annotations at all, the description is the only source of behavior, but it does not mention side effects, external network calls, output format, or failure behavior. The only disclosed trait is that Open-Meteo is involved; everything else is left to the agent.

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

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

The single sentence is concise and front-loaded, but this is under-specification rather than effective conciseness. For a tool with seven parameters and no output schema, one fragment cannot carry the required 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?

Given seven optional-looking string parameters, no annotations, and no output schema, the description is far from complete. It omits the required input, return shape, and behavior with the many parameters that seem unrelated to latitude/longitude.

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

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

Schema descriptions exist for all seven parameters, so the baseline is 3. The description adds a hint that 'place' is relevant, but it does not connect which parameter carries the place or how the non-place parameters (ref, json, path) fit.

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

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

The description states the output (latitude and longitude) and the backend (Open-Meteo), so an agent can infer a geocoding purpose. However, it is a verbless fragment and never names a resource or distinguishes itself from siblings like 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 choose geo-hint over alternatives, what kind of place input is expected, or any exclusions. The agent must guess how it relates to weather-hint, timezone, and the other sibling tools.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only states the parsing action and does not mention read-only behavior, error handling for non-GitHub URLs, what happens to the other input fields, or the 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 concise sentence with no filler. The verb and target are front-loaded, making it easy to scan 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?

This is a 9-parameter tool with no output schema and no annotations. The description is too thin: it does not clarify what the tool returns, how it treats non-URL parameters, or what happens with invalid GitHub URLs.

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%, with every parameter already documented in the input schema. The description adds little beyond identifying that the URL is a GitHub URL, 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 clearly states the action ('Parse') and the resource ('owner and repo from a GitHub URL'). It is specific enough to understand the tool's main job, though it does not explicitly distinguish itself from sibling shape tools like domain-shape or figma-url-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?

No guidance is given about when to use this tool versus alternatives such as normalize-url, browser-url-ok, or domain-shape. The context is only implied by the tool name and brief description.

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

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

With no annotations, the description carries the behavioral burden; it does disclose one non-obvious trait ('Titles discarded') and the 'current' snapshot aspect. It does not state whether this is a live network read, whether all parameters are ignored, or what the return type is, leaving meaningful gaps.

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

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

Two short sentences, action first, no filler. The second sentence ('Titles discarded') earns its place by clarifying output scope, so the definition is efficient and well-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?

Despite a simple surface purpose, the definition omits the return value format, the fact that no parameter appears necessary, and any relationship to the large unrelated optional-parameter set. With no output schema or annotations, more context is needed for reliable 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 coverage is 100%, so the baseline is 3 even though the description adds no parameter-level meaning. The nine optional parameters have descriptions, but the tool description never clarifies which, if any, are relevant to counting HN stories, so the mapping is unclear.

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 ('Count current Hacker News front-page stories') and adds an output constraint ('Titles discarded'), so an agent can tell it produces a count rather than story details. It does not explicitly differentiate from siblings such as web-fetch, which prevents 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 intended use is implied: use when a count of the current Hacker News front page is needed, and 'Titles discarded' warns that title details are not returned. However, no explicit when-not-to-use guidance or alternative tools are named, so routing still depends on inference.

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

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

There are no annotations, so the description must carry the behavioral burden. It only restates the domain of the output and says nothing about side effects, return format, required permissions, or whether this is a read-only lookup.

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 and is front-loaded, but for a tool with seven parameters and no other documentation it is under-specified rather than appropriately sized.

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 no parameter explanation, an agent cannot reliably determine what to provide or what to expect. The description only names the general topic and leaves nearly all invocation details unresolved.

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 descriptions in the input schema, so the baseline is 3. However, the description adds no information about parameters, and the schema descriptions for ref, url, city, feed, host, json, and path appear unrelated 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 clearly identifies the tool's resource (common IANA timezone names) and its intended use case (clock calls). It is not a tautology and provides enough to distinguish it from the timezone and utc-time siblings, though it lacks an explicit verb.

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' gives a weak contextual hint, but there is no explicit guidance about when to use this tool versus alternatives, no when-not-to-use conditions, and no mention of 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?

The description only says it fetches and returns group counts; it does not disclose behavior around ignored/discarded parameters, URL/host handling, error cases, or output format. With no annotations provided, the description carries the full burden and doesn't meet it.

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

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

The description is a single sentence with no filler, front-loading the verb and resource. 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 seven parameters and no annotations, the one-line description is far from complete: it omits how to specify the target URL/host, what 'group counts' means, and what the response looks like. The agent is left with too much ambiguity to call it reliably.

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 seven parameters, but none of their descriptions mention robots.txt, and the description provides no mapping to the correct parameter. Several parameters are described as discarded or unrelated to robots (city, feed, json, path), so the agent cannot determine what to pass for the target site.

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 ('Fetch'), a clear resource ('a public robots.txt'), and a precise output ('return group counts only'). It is distinct from generic siblings like web-fetch or fetch-status because it names robots.txt inspection as its 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 instead of siblings such as web-fetch, fetch-status, or normalize-url, nor any exclusions. Usage is only implied by the name and the short description, leaving the agent to infer the calling context.

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

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

With no annotations, the description carries the burden for behavioral disclosure. "Key discarded" explicitly indicates that the key is not retained, and "Check" suggests a read-only operation. Still, it does not disclose side effects, return behavior, or failure modes.

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

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

The description is extremely short and both sentences carry meaningful information: purpose and disposal behavior. No wasted words, though the brevity contributes to the lack of necessary 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 parameters, no annotations, and no output schema, this description is far from sufficient for an agent to invoke the tool correctly. The agent cannot determine required inputs, what output to expect, or how the Jira key relates to the schema fields.

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

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

The input schema has descriptions for all seven properties, but none of them clearly identifies a "Jira issue key" parameter. The description adds no mapping between "key" and any schema field, leaving an agent uncertain which value 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 clearly states a specific action and resource: "Check a Jira issue key shape." This distinguishes it from sibling shape tools like domain-shape or figma-url-shape. However, it does not clarify what the check returns or what a valid shape is.

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

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

There is no guidance on when to use this tool versus alternatives such as github-repo-shape or normalize-url. The description implies it is for Jira keys but gives no context, exclusions, 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?

The description discloses one important behavior: the response body is discarded, so callers should expect only a status code. However, with no annotations, it does not mention whether this makes a network request, how redirects/errors/timeouts are handled, or whether any authentication or rate limits apply.

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 status-check behavior is front-loaded and 'Body discarded' is a useful qualifier. The description earns its length.

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

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

The tool has nine optional parameters, no required fields, no output schema, and no annotations, yet the description explains only a narrow URL-status use case. It never explains how parameters relate, what the return value looks like beyond 'HTTP status', or how this tool differs from sibling URL/status tools.

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

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

Input schema coverage is 100%, so the schema already documents all nine parameters. The description adds no parameter-level meaning beyond the schema, though 'Body discarded' loosely aligns with the schema's repeated 'discarded after...' notes. Baseline 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 operation—checking the HTTP status of a public library docs URL—and explicitly notes the body is discarded. This is clear enough to distinguish it from body-returning tools like web-fetch, but it doesn't name or contrast with the closest 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?

No guidance is given about when to prefer this tool over fetch-status, browser-url-ok, or web-fetch. The 'public library docs URL' scope is an implicit hint, but there are no explicit when-to-use, when-not-to-use, or alternative-selection 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 burden of explaining side effects and behavior. It mentions that values are discarded, but it does not state whether the operation is read-only, what errors may occur, or what happens with invalid JSON.

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 free of fluff, containing only the core action and a note about values. It is efficient, though it omits important 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?

The tool has nine parameters and no output schema, but the description does not explain expected input, output, errors, or which parameters are relevant. The description is too thin for an agent to use 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?

Although every parameter has a schema description, the tool description does not clarify which parameter is the JSON object or how the many unrelated parameters (ref, url, city, feed, host, path, zone, query) relate to counting keys. The wording 'discarded after the check' on json conflicts with the stated purpose of counting keys.

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'—and adds that values are discarded. This distinguishes it from a validation or normalization tool, though it does not explicitly differentiate it from sibling tools such as 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 provided about when to choose this tool over alternatives, what input is expected, or how the result should be used. The description only states the action and gives no context for selection.

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

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

The description adds a useful behavioral detail: query and fragment are dropped. However, no annotations exist, so the description carries the full burden. It does not mention failure behavior for invalid URLs, whether extra inputs are ignored, or the exact shape of the returned object.

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

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

Two short sentences with no filler. The main outcome is front-loaded and the key transformation is stated in a second sentence. 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?

Despite a seemingly simple statement, the tool has an unexpectedly large and confusing schema, no output schema, and no annotations. The description does not resolve which parameter is required, what the return structure looks like, or how it fits with the many URL-related sibling tools, so the agent is left with significant 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?

The schema has eight parameters, and while each has a description, the tool description does not clarify that `url` is the primary input. The output terms 'host' and 'path' collide with parameter names `host` and `path`, which could confuse an agent about whether those are inputs or 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 uses a specific verb ('Return') and identifies the resource ('URL') plus the exact output fields ('origin, host, and path'). It also states a key transformation ('Query and fragment are dropped'), which helps separate it from URL-checking siblings like browser-url-ok, though it does not explicitly name 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?

There is no guidance on when to use normalize-url versus sibling tools such as domain-shape, figma-url-shape, or browser-url-ok. It only states what the tool does, leaving the agent to infer when it is the right choice.

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, but it only discloses that no browser is launched; it does not mention network access, side effects, read-only behavior, or what 'can be opened' means.

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; both clauses ('Check whether a URL can be opened' and 'No browser is launched') earn their 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 nine optional parameters, no output schema, and no annotation context, the description is too terse: it omits which inputs matter, what the result/exit condition is, and any error or edge-case 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; however, the tool description itself does not clarify which of the nine optional parameters are used (probably url) or how the unrelated parameters should be treated, so it adds little parameter-level meaning.

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

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

The description states a specific action ('Check whether a URL can be opened') and adds a useful behavioral qualifier ('No browser is launched'), which helps distinguish it from browser-based sibling tools. It does not specify the return kind, but the core purpose is clear.

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

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

No guidance is given for when to choose this tool over alternatives such as browser-url-ok, fetch-status, or normalize-url, and no 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?

Without annotations, the description must disclose behavior itself; 'Query discarded' is a useful privacy signal, but it does not describe return format, whether a missing query yields an error, or how character counting is defined. The description's mismatch with the schema further obscures the runtime 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 text is very short and front-loads the action, so there is no waste. However, it is so terse that necessary information (which parameter is the query, what counts as a character) is missing, making it under-specification rather than efficient specification.

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 leaves no explanation of how to form a valid call or what result to expect. The single meaningful guarantee is that the input is discarded, which is insufficient for an agent to 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?

Although the input schema has high per-property description coverage, the description refers to a 'search query' that does not map to any of the seven properties (ref, url, city, feed, host, json, path). The description therefore adds no usable parameter semantics and actually makes invocation ambiguous.

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

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

The description states a specific action ('Count characters in a search query') but the input schema contains no `query` property, so the tool's purpose cannot be tied to a callable parameter. It essentially restates the tool name and does not distinguish itself from sibling counting tools like hn-front-count or memory-key-count.

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 choose this tool or avoid alternatives, and there is no parameter named `query`, so an agent cannot infer which input supplies the value to count. The phrase 'Query discarded' addresses post-call handling, not tool selection.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It says nothing about side effects, input handling, or output format. The schema hints that inputs are 'discarded after the shape check' but the description does not clarify this behavior. This is a severe gap for a tool that likely performs validation.

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

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

The description is one sentence, which is concise, but it is under-specified for a tool with 9 parameters and no annotations. It lacks essential operational details, so brevity here is not appropriate; it sacrifices completeness.

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 complexity (9 parameters, no output schema, no annotations), the description is grossly incomplete. It does not explain what the tool returns, how parameters are used, or when to invoke it. An agent has no way 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?

Schema description coverage is 100%, so the baseline is 3. However, the description adds zero meaning to the parameters, and the schema's own descriptions (e.g., 'discarded after the shape check') are cryptic and disconnected from the stated catalog purpose. The tool description fails to explain how parameters map to the catalog, lowering the score.

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 resource (catalog of HTTP status codes) but provides no verb or action. It is unclear how the 9 diverse parameters relate to the catalog, and there is no distinction from sibling tools like fetch-status or browser-url-ok. The purpose is only vaguely implied as a reference.

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 siblings. There are no conditions, prerequisites, or alternative names mentioned. An agent cannot determine if this is the right tool for a task.

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 burden. It does disclose a meaningful behavior: the prompt is discarded and a fixed template is returned. However, it does not mention side effects, failure modes, or that all input parameters are effectively ignored; only the schema hints at that.

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 return value is front-loaded and the caveat about the prompt being discarded is cleanly separated.

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 nearly adequate for a simple fixed-template tool, but it omits when to use it and what the three-step template actually contains. With no output schema and no annotations, an agent gets only a minimal functional description plus the schema's per-field notes.

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

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

The description adds no parameter semantics, but the input schema provides a description for every one of the eight parameters. With high schema coverage, the baseline of 3 applies; the description does not need to 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 states a clear action and object: 'Return a three-step thinking template.' The verb+resource makes the tool distinguishable from the many sibling shape-check and fetch utilities, though it does not explicitly contrast with any sibling.

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

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

There is no guidance on when to use this tool instead of alternatives. 'Prompt discarded' warns about what will not be used, but it does not give an agent any condition, context, or competing tool to prefer.

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 gives no behavioral context. It does not explain that the many schema parameters (ref, url, city, feed, host, json, path) are discarded after checks or how a timezone is actually supplied. This leaves the tool's runtime behavior largely opaque.

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

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

The description is one short, front-loaded sentence with no wasted words. It is concise, though slightly too sparse to fully compensate for the schema mismatch.

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

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

A seven-parameter tool with no output schema needs more than a one-line purpose statement. The description omits how the timezone is specified, what the response looks like, and how this relates to the unrelated-looking parameters, so an agent cannot call 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 provides descriptions for all seven parameters, but none of them is a timezone name; they refer to Git refs, URLs, weather hints, feeds, hostnames, JSON, and paths. The description adds no parameter-level meaning to bridge that gap, so an agent still cannot tell which parameter to populate to request a 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 names a specific resource, a named IANA timezone, and implies the action of retrieving the current time. That is enough to distinguish it from siblings like utc-time and iana-zones. It lacks an explicit verb, and the stated purpose is undercut by a schema that exposes no timezone parameter, so it is not quite 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 on when to use this tool instead of the obvious siblings utc-time or iana-zones. No conditions, exclusions, or alternative selection hints 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 carries the burden of disclosing side effects and parameter behavior. 'Current UTC timestamp' only implies a read-only clock read; it does not explain that the many input parameters appear to be accepted but discarded, nor does it describe the output format. This is a significant gap.

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

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

The description is extremely short and front-loaded, with no wasted words. It is concise, but the extreme brevity also reflects under-specification; a single sentence stating the output is structurally fine but does not carry the needed usage or 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 no annotations, no output schema, and nine optional parameters, this definition is incomplete. It does not explain the return format, whether inputs are ignored, or how it relates to sibling time-related tools. An agent could easily call it with irrelevant parameters or confuse it with timezone.

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 semantics. The schema documents each parameter and notes that several are discarded, but the description still leaves unclear whether any parameter can affect the returned timestamp.

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

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

The description clearly states that the tool returns the current UTC timestamp, which is a specific, recognizable output. It is not a tautology because 'timestamp' adds precision over the tool name, though it does not explicitly differentiate from siblings like timezone 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?

There is no guidance about when to use this tool versus alternatives such as timezone or iana-zones. The description does not mention that no arguments are needed, nor does it explain why the schema exposes nine optional parameters.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does state 'The body is discarded,' which conveys that the input is not retained—a meaningful privacy-relevant trait. However, it does not disclose the return value, failure behavior, or whether any external call is made, so transparency is partial.

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

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

The description is a single short sentence—concise and front-loaded with the primary purpose. However, it is so sparse that it omits essential guidance about which parameter to populate. It saves words but at the cost of usefulness.

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 7 loosely related parameters, no required field, and no output schema, the description is insufficient. The agent cannot determine which parameter is the JSON to validate, nor what result to expect (e.g., boolean, error, or status). The description only adds the discard behavior, leaving critical invocation details unstated.

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

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

The input schema has descriptions for all 7 parameters, so the schema itself provides high coverage (baseline 3). But the description's phrase 'a body' does not map to any defined parameter. The schema's 'json' parameter is the actual JSON text to validate, and the description fails to direct the agent to it, potentially causing invocation errors.

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

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

The description states a specific verb and resource: 'Check whether a body is valid JSON.' This clearly identifies the tool's purpose and distinguishes it from sibling validators like github-repo-shape or wiki-title-ok. The only ambiguity is the reference to 'a body' rather than naming the 'json' parameter, which slightly reduces clarity.

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

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

There is no guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. The description merely states what it does, leaving the agent to infer appropriate usage from the tool name and context. No sibling tool is referenced or compared.

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 only mentions that the data comes from Open-Meteo, but it does not disclose that many of the input schema's parameters are unrelated to the weather lookup, whether authentication is needed, what the return shape is, or how failures are handled.

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

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

The description is a single sentence: 'Current temperature for a city via Open-Meteo.' It is front-loaded with the core verb and resource, contains no filler, and is easy to scan.

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

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

The tool is simple in concept, but the definition is incomplete for reliable invocation. There is no output schema, no mention of return units or response format, no statement that only 'city' matters, and no explanation of the many unrelated schema properties. An agent would struggle to know how to call this correctly and what 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?

The input schema already documents each parameter, so the baseline is neutral. The description adds value by clarifying that 'city' is the relevant input for the temperature lookup, but it does not state that the other parameters are irrelevant or ignored, and no parameters are marked required. The schema descriptions for ref, url, feed, host, json, and path suggest unrelated behavior, adding ambiguity.

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

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

The description states a specific verb and resource: returns the current temperature for a city, via the Open-Meteo provider. It is concise and clearly identifies the tool's core function, though it does not explicitly differentiate it from sibling hint tools or address the confusingly broad input schema.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention prerequisites, exclusions, or how it differs from sibling tools like geo-hint or lib-docs-hint, leaving the agent to infer usage solely from the name and one-liner.

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 clearly states the body is discarded and the output is status/content type, but it omits network behavior such as redirects, timeouts, authentication, or error handling, which are relevant for a tool that fetches URLs.

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-loaded with the core function and a clear limitation. Every word earns its place; there is no redundancy or filler.

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

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

For a tool with nine optional parameters, no output schema, and no annotations, the description is incomplete. It covers only the URL case, does not explain how to choose among the many schema parameters, and does not describe expected status/error 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. The description adds little beyond saying 'public URL', which roughly maps to the url parameter, and does not help reconcile the other eight schema parameters with the URL-focused 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 operation: returning HTTP status and content type for a public URL, and 'Body discarded' distinguishes it from a full page fetch. It does not, however, differentiate it from sibling tools like fetch-status or browser-url-ok, 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 usage for lightweight URL checks by noting 'HTTP status and content type' and 'Body discarded'. It gives no explicit guidance about when to use this tool instead of fetch-status, browser-url-ok, or normalize-url, so the usage context is only implied.

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

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

The description discloses one useful behavioral trait: 'Title discarded after the call.' This indicates the input is not retained, which is valuable privacy-relevant information. However, with no annotations present, the description still omits other relevant behaviors such as read-only status, network dependence, rate limits, or return 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 a single, front-loaded sentence with no filler words. Both clauses contribute information: the tool's operation and the discard 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?

This tool is nearly impossible to invoke correctly from the description alone: there is no title parameter, no return value description, and no output schema. The schema contains seven unrelated-looking parameters, and the description fails to explain how any of them relate to the stated purpose.

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

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

The schema provides descriptions for all seven parameters, but those descriptions are unrelated to the stated purpose: none reference a Wikipedia title. The description adds no mapping between its 'title' concept and any schema property, and instead creates confusion by mentioning a title that does not exist among the 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: 'Check whether a Wikipedia title exists.' It is not a tautology and seems distinct from sibling tools like browser-url-ok or web-fetch. However, no parameter is identified as carrying the title, so the stated purpose is not fully actionable from the description alone.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor any prerequisites or exclusions. The only implied usage is when one needs to verify a Wikipedia title, but no context is provided about choosing this over web-fetch 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.