Currency SAR

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

With no annotations, the description carries the behavioral disclosure burden. It adds a useful privacy note ('Task text discarded') and lists returned artifact classes, but it leaves operational traits unstated, such as whether calls incur charges, require auth, or involve network requests.

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?

Three short sentences carry the core purpose, return contents, and discard policy with no filler. The purpose is front-loaded and 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?

The tool has no output schema, no annotations, and 9 optional parameters, yet the description doesn't explain invocation shape, which parameters to actually use, or what the returned artifacts look like. The cost/auth implications of 'pay-per-call' are also left ambiguous, so an agent would struggle to 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?

Schema description coverage is 100%, so the baseline is 3. The schema already documents all 9 parameters, but the description adds no guidance on which parameter to pass or why inputs are 'discarded after the shape 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 names a specific verb and resource ('Find a public pay-per-call tool gateway (Monid)') and enumerates concrete return artifacts: CLI setup, how-it-works, skill file, and remote MCP hops. This clearly distinguishes it from the sibling shape-checkers and hints.

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 makes the intended scenario clear—looking up the Monid pay-per-call gateway—and lists what the caller will receive. However, it never contrasts this tool with sibling alternatives or states 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 carries the full burden of behavioral disclosure. It reveals only that no browser is launched, but does not say whether the tool makes a network request, has side effects, what it returns, or what discarding inputs means for the check.

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

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

The two sentences are tightly written and front-loaded: the purpose comes first, followed by a key constraint. No words are wasted, though the terse style may be too spare for the schema's complexity.

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

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

Given nine optional parameters, no annotations, and no output schema, this description is insufficient. It does not explain how to choose among the parameters, what 'can be opened' means, or what kind of result to expect, so an agent cannot reliably invoke the tool.

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

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

The schema already provides per-parameter descriptions for all nine parameters, so the baseline is 3. The tool description adds no parameter-level insight and does not resolve how the unrelated-looking parameters (ref, city, json, path, query) relate to checking a 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 states a clear action – check whether a URL can be opened – and adds a useful constraint that no browser is launched. However, it never clarifies what 'can be opened' means (syntax validity vs reachability), and the 9-parameter input schema includes unrelated values such as city, ref, and json, leaving the tool's actual purpose 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 only usage guidance is the implicit exclusion that no browser is launched, which hints not to use it when browser rendering is needed. It does not name alternative tools such as fetch-status, normalize-url, or playwright-url-ok, nor does it define conditions for when this tool should be selected.

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 statement 'Expression discarded' is a useful behavioral hint: it indicates the expression is not retained or returned. With no annotations provided, the description carries the burden of behavioral disclosure, but it does not mention errors, output behavior, or whether any side effects occur, so the transparency is only partial.

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

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

The description is only two short sentences, front-loaded with the core verb and resource, with no filler. It is concise, though slightly too terse to be fully appropriate given 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?

With no annotations, no output schema, and nine optional parameters, the description is not sufficient for reliable invocation. The main missing piece is how to pass the arithmetic expression, and the description also fails to mention what the tool returns or what happens on invalid expressions.

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

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

Although every schema parameter has a description, none of the nine parameters obviously represents an arithmetic expression. The tool description says 'Evaluate a+b style arithmetic' but does not map that expression to any schema field, leaving an agent unsure 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 clearly identifies a concrete operation: evaluate arithmetic expressions in an 'a+b' style. Among the sibling tools, none other claims arithmetic evaluation, so it is distinguishable from them. However, it does not say how the expression is supplied, which slightly weakens clarity.

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

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

There is no guidance about when to use this tool instead of alternatives, nor any mention of exclusions or prerequisites. The description only states what the tool does, not under what circumstances an agent should select 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?

No annotations are present, so the description carries the full disclosure burden. It does disclose that page content is not stored, which is a useful behavioral guarantee. Still, it leaves out other relevant behavior such as whether a network request is made, whether redirects are followed, or what side effects exist for the non-URL parameters.

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

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

The description is concise: two short sentences with no filler. The primary behavior and a key limitation are front-loaded, and every word adds useful information.

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

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

For a tool with 9 parameters, no output schema, and 26 sibling tools, this description is under-specified. It does not explain whether exactly one parameter should be provided, what the response format is, or how this tool relates to the many overlapping URL and fetch tools in the sibling list.

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 overall output intent but no per-parameter guidance. The presence of parameters like city, json, and path is not reconciled with the description's URL-only framing, which could confuse an agent about which parameters are actually relevant.

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

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

The description states a concrete action and output: return host, scheme, and HTTP status for a URL. It also adds a meaningful boundary with 'Page content is not stored.' However, it does not explicitly differentiate itself from similar sibling tools like fetch-status or normalize-url, and the input schema includes many unrelated-looking parameters that muddy the overall 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?

The description implies a metadata-only use case through 'Page content is not stored,' but it never explicitly says when to prefer this tool over alternatives such as web-fetch, fetch-status, or normalize-url. No sibling tools are named and no when-not-to-use guidance is provided beyond the single storage disclaimer.

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, and it does provide a meaningful data-handling guarantee: identifiers are not retained, and the schema repeats that many values are discarded. But it does not disclose whether the tool is read-only, whether it makes network calls, or what its classification logic/return behavior is, which leaves a notable transparency 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 two short sentences with the main action first and the privacy guarantee second. There is no padding, and both sentences earn their place structurally. It is concise, though the brevity contributes to the lack of operational detail.

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

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

This is a multi-parameter tool with no output schema and no annotations, yet the description does not explain how many parameters to provide, whether one or several should be used together, what classification result will look like, or how it relates to the many sibling tools. The schema descriptions and privacy note help, but an agent cannot confidently invoke this tool correctly from the definition alone.

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

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

Schema description coverage is 100%, and the parameter descriptions already explain each field's role and discard behavior (Git ref, URL, city, feed, host, JSON, path, phone, email, IP). The description adds no new parameter-level meaning, so the baseline of 3 is appropriate.

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

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

The description does more than restate the name: it says the tool will show how the current request is classified and adds a privacy guarantee. However, 'classified' is left undefined—no categories, labels, or output format are given, so the purpose remains vague. It also does not distinguish this tool from sibling classification/shape tools such as domain-shape or 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?

There is no when-to-use guidance, no mention of when not to use it, and no reference to alternatives. The privacy note ('No identifiers are retained') hints that it may be safe for sensitive inputs, but that is a property of the tool, not a directive for choosing it over siblings.

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

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

With no annotations, the description must carry the behavioral burden. It does disclose one important non-behavior—no WHOIS or ownership lookup—and the core transformation is clear. But it does not describe the return shape, how the eight non-host parameters are handled, or any edge cases, 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 one sentence with no filler and puts the core action first, followed by a clarifying exclusion. It is concise, though arguably too short for a tool with nine parameters and no output 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?

The tool has nine optional parameters, no annotations, and no output schema, yet the description covers only the hostname-splitting scenario. An agent is left without guidance on which parameter to pass, whether multiple parameters are allowed, or what result to expect, so the definition is substantially 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; every parameter is already described in the input schema. The tool description adds no parameter meaning beyond 'hostname', and it does not clarify how the other parameters relate to the stated domain-splitting purpose.

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

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

The description states a specific action and object: 'Split a hostname into labels', and it usefully excludes WHOIS/ownership lookups, which helps distinguish it from ownership-oriented domain tools. However, the input schema exposes nine unrelated optional parameters, so the description does not explain the full scope of what the tool accepts, preventing a perfect score.

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

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

There is no guidance about when to choose this tool over sibling shape/validation tools such as github-repo-shape or jira-key-shape. The phrase 'without WHOIS or ownership data' hints at a use case, but it never states conditions, exclusions, 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?

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose the HEAD method and status-only output, which is useful, but it does not mention what happens when other input parameters are supplied, whether there are side effects, redirect behavior, or the return format. This is behaviorally incomplete for the schema presented.

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, which is excellent for a simple URL status check. However, given the nine-parameter schema, it is too terse and sacrifices necessary context 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?

The tool has high complexity: 9 optional parameters, no output schema, and no annotations. The description only covers one narrow URL HEAD use case and leaves the purpose of the other parameters, the exact return value, and error handling completely unexplained.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds that `url` is the target of a HEAD request, but the schema's own `url` description says 'HTTPS URL to normalize or cite', which conflicts with that reading. No meaning is added for the other eight 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 names a specific action and output: HEAD a public URL and return status only. However, the input schema exposes nine optional parameters (ref, city, feed, json, path, zone, query, host, url) that the description never acknowledges, so the stated purpose is too narrow and potentially misleading about the tool's actual 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 explicit guidance about when to use this tool versus siblings like web-fetch, browser-url-ok, or normalize-url. 'Return status only' weakly implies a lightweight check, but it does not say when not to use it, nor does it explain how to choose among the 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?

No annotations are provided, so the description carries the full burden of disclosing behavior. It only says the path is discarded; it does not state whether the tool performs network access, what it returns, whether it validates in addition to parsing, or what side effects might exist.

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

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

The description is very short and front-loads the core purpose with no wasted words. The second sentence is terse and somewhat ambiguous, but it still communicates a distinct behavioral detail.

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

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

Given the large optional schema, complete lack of annotations, and no output schema, this description is too thin. It fails to explain how the Figma URL should be supplied, what 'shape' checking entails, or what response format the agent should 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?

Although the schema covers 100% of the parameters, the description does not clarify which of the nine optional parameters is the Figma URL or how they relate to the tool. The phrase 'Path discarded' is ambiguous against the schema's 'path' parameter, which is described as 'File path to check; no disk access'.

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 verb ('parse') and a specific resource ('Figma file URL'), which distinguishes it from generic URL tools like normalize-url. However, it stops short of explicitly differentiating itself from other 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 mention of 'Figma file URL' implies the tool is for Figma URLs, giving some usage context. But there is no explicit guidance about when to choose this tool over sibling shape/check tools, nor any exclusions or alternative routing.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does state one important trait: 'No disk access,' which clarifies that the check is non-invasive and does not verify existence or permissions. However, it says nothing about return values, error behavior, or what exactly 'safe' means, so the disclosure is incomplete.

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 highly concise and front-loaded: the first sentence states the core purpose, and the second adds meaningful no-side-effect information. There is no filler or redundancy, though it is so terse that it sacrifices helpful detail.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, a seven-word description is not enough. It does not identify which parameter to pass, whether multiple parameters may be supplied, what 'safe' means, or what the tool returns. An agent would have difficulty invoking this correctly without extra information.

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

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

Schema description coverage is 100%, so the baseline is 3 even without parameter details in the description. The description itself adds no parameter guidance, and the schema exposes eight additional unrelated-looking optional parameters, which could confuse an agent. But since each parameter already has a clear schema description, 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 verb ('Check') and resource ('a path'), and 'No disk access' signals that this is a purely syntactic or lexical safety check. However, 'looks safe' is ambiguous, and it does not explicitly differentiate this from sibling validators like browser-url-ok or normalize-url, so it misses the highest bar.

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 or when to prefer an alternative. 'No disk access' weakly implies a pre-flight validation use case, but the description never says 'use before filesystem access' or 'use for paths only, not URLs,' leaving the agent to infer the intended 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 full burden of behavioral disclosure. It mentions use of Open-Meteo, implying an external network call, but does not describe rate limits, output format, side effects, or that most schema fields are discarded. The schema's per-parameter 'discarded' notes are not sufficient to explain the tool's overall 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 brief and front-loaded, but it is under-specified rather than appropriately concise. It omits critical operational details and is not sufficient for an agent to call the tool correctly.

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, the description is far too incomplete. It fails to specify which parameter to use, what the return value looks like, and how to handle the many irrelevant parameters. This is a severe gap for a tool with this level of ambiguity.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds no parameter-specific meaning, leaving the mapping from 'place' to the city or query parameter unclear. The city parameter description confusingly references a 'public weather hint' rather than geocoding, so the description does not clarify the intended input.

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 indicates that the tool provides latitude and longitude for a place and names the external service (Open-Meteo). This distinguishes it from weather, timezone, and validation siblings. However, it lacks an explicit verb and does not identify which input parameter represents the place.

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

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

The description gives no guidance on when to use this tool instead of alternatives like weather-hint or timezone. It does not state that the city parameter should be supplied or that other parameters are ignored. There are no exclusions or alternative tool references.

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 is the only behavioral signal, and it only says 'Parse...'. It does not disclose return format, failure behavior for invalid/non-GitHub URLs, or how it treats the many unrelated optional schema fields (city, feed, json, path, query).

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

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

A single nine-word sentence with no filler. The key action and object are front-loaded, and every word earns its place.

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

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

Given no annotations, no output schema, and a noisy nine-parameter schema, one sentence is not enough for an agent to know the expected input format or return value. It should at least mention that only `url` matters and what the tool returns for valid/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 description coverage is 100%, so the baseline is 3. The description does add a useful mapping from 'GitHub URL' to the `url` parameter, but it provides no guidance about the other eight optional parameters or which ones are relevant.

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

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

The description states a specific verb ('Parse'), specific outputs ('owner and repo'), and a specific input class ('GitHub URL'). This clearly distinguishes it from sibling URL/shape tools such as normalize-url 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 GitHub-URL scope implies when the tool should be used, but the description never states an explicit trigger, nor does it mention alternatives or when-not-to-use cases. Selection guidance is left to inference.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It conveys that the operation is read-only-ish ('Count current...') and that titles are discarded, which is useful. But it does not disclose network behavior, side effects, or how the unrelated optional parameters are treated, leaving significant behavioral gaps.

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

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

The description is two short sentences with no filler. It front-loads the core action and adds only the significant behavioral caveat that titles are discarded.

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 complete for a trivial zero-parameter count, but the actual schema exposes nine unrelated optional parameters and there is no output schema. The description does not explain whether any parameter should be supplied, how the count is returned, or what 'current' means in terms of fetch behavior, so an agent is left with unresolved ambiguity.

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

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

Schema coverage is 100%, so every parameter already has a description and the baseline is 3. The tool description adds no parameter-specific guidance, and it does not clarify whether the nine optional parameters are meaningful for an HN count or simply ignored, but it does not contradict the schema either.

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

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

The description opens with a specific verb and resource: 'Count current Hacker News front-page stories.' The added 'Titles discarded' clarifies that the tool returns only a count, not the story titles, which distinguishes it from a fetch or list operation. This is clearly differentiated from sibling count tools like memory-key-count and search-query-len.

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 a count of current Hacker News front-page stories is needed. However, it does not explicitly state when to prefer it over alternatives nor mention any exclusions or prerequisites, so the guidance 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?

No annotations are provided, so the description must disclose behavior itself. It only states the data content; it does not say that the tool returns a list, that it has no side effects, that it takes no meaningful arguments, or what the response 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 a single phrase with no filler, which is efficient. However, it is a fragment rather than a complete sentence and is too sparse to serve as a standalone guide, making it under-specified rather than 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?

With no annotations, no output schema, and nine parameters that are not connected to the stated purpose, this description is insufficient for reliable invocation. It needs at least an explicit statement that no arguments are required and that it returns a list of common IANA timezone names.

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

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

Schema description coverage is 100%, so the schema already documents each parameter, giving a baseline of 3. The tool description adds no parameter-specific meaning, and several schema parameters (ref, url, json, path) appear unrelated to timezone names, but the schema still carries the descriptive burden.

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 the resource ('Common IANA timezone names') and its intended context ('for clock calls'), so an agent can infer this is a list of standard zone names. It lacks an explicit verb like 'list' or 'return' and does not compare with sibling tools, so it is clear but not maximally specific.

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' implies the tool should be used when an agent needs timezone names for clock/time operations. There is no explicit guidance about when not to use it or how it relates to siblings such as timezone and utc-time, so the guidance 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?

There are no annotations, so the description must carry the behavioral disclosure burden. It does state the operation is a public network fetch and that only group counts are returned, implying read-only behavior and limited output. However, it does not mention error handling, redirects, authentication needs, rate limits, or what happens if robots.txt is missing.

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

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

The description is a single, front-loaded sentence with no wasted words. It clearly communicates the core action and the output restriction.

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

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

Given nine optional parameters, no required parameters, no annotations, and no output schema, one sentence is insufficient. The description does not explain which parameter supplies the robots.txt URL, what 'group counts' means, or what the return shape looks like. This leaves too much ambiguity for an agent to invoke the tool 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 schema coverage is 100%, the parameter descriptions are generic and mostly irrelevant to robots.txt: 'url' is described as 'HTTPS URL to normalize or cite', 'city' as a weather hint, 'json' as text to validate, and 'query' as search text. The tool description adds no parameter guidance, so an agent cannot reliably determine which of the nine optional parameters are actually needed to fetch robots.txt.

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: 'Fetch a public robots.txt'. It also clarifies the limited output scope ('return group counts only'), which differentiates it from broad fetch tools like web-fetch or fetch-status. The purpose is unambiguous even without inspecting the schema.

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

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

The use case is implied by the description: use this when you need group counts from a public robots.txt. However, it does not explicitly state when not to use it or compare it with alternatives such as web-fetch, domain-shape, or fetch-status. The guidance is inferable but not explicit.

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

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

With no annotations, the description carries the burden; 'Key discarded' is a useful privacy/retention behavior that goes beyond the tool name. But it does not disclose whether the check returns a boolean, what happens on malformed input, or whether any other data 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 only two short sentences and front-loads the core action. It is concise with no filler, though the second sentence is slightly cryptic because the schema has no key parameter.

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

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

For a tool with nine parameters, no annotations, and no output schema, this description is far too thin: it does not say which parameter is the Jira key, what a valid shape is, what the tool returns, or why the other parameters appear. The schema mismatch makes the tool effectively uncallable without additional context.

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

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

Although schema description coverage is 100%, the description references a 'key' that does not exist in the schema; the nine schema properties (ref, url, city, feed, host, json, path, zone, query) are unrelated to a Jira issue key. The description thus fails to map the Jira key to any actual parameter, making the tool difficult to invoke.

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 a Jira issue key shape', which distinguishes it from sibling shape-checkers like domain-shape and github-repo-shape. It is not a tautology, but it never names the input parameter or the expected return, so it is not fully self-contained.

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 by the domain ('Jira issue key'), so an agent can infer it should be used when a Jira key needs validating. However, it gives no explicit when-to-use guidance, no exclusions, and no comparison to similar shape-check siblings, leaving selection to inference.

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

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

The description does add one meaningful behavioral detail: 'Body discarded' clarifies that only the HTTP status is returned, not the response content. With no annotations present, though, it omits other useful context such as whether a network request is made, how errors or redirects are handled, and that most of the nine schema parameters are ignored by this 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 very short and front-loaded: the first sentence conveys purpose and the second adds behavioral detail. However, 'HTTP status for...' is a fragment and the terseness leaves 'public library docs URL' ambiguous.

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, a two-sentence description is insufficient. It does not tell an agent which parameter to populate, what happens when multiple parameters are provided, or what the exact response format is beyond 'HTTP status' and 'Body discarded.'

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

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

Schema description coverage is 100%, so the baseline is 3. The description implies the URL is the operative input but does not explicitly map 'public library docs URL' to the url parameter or explain the role of the other eight optional fields.

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

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

The description states the tool returns an HTTP status for a public library docs URL and discards the body, so the core output and target resource are identifiable. However, it does not explicitly name the relevant input parameter or differentiate this from siblings like 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?

There is no guidance about when to use this tool versus alternatives such as fetch-status, web-fetch, or browser-url-ok. No exclusions, prerequisites, or context are provided, leaving usage entirely to inference.

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

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

With no annotations present, the description must carry the behavioral burden. It discloses that values are discarded, which is meaningful, but it does not explain whether counting is top-level or recursive, whether it returns a plain number, or whether the input should be passed through the json parameter.

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

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

The description is two short sentences with no filler. The main action is front-loaded, and the discarded-values note is efficiently placed second.

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

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

The input schema is large and confusing, with nine optional parameters drawn from unrelated domains, and there is no output schema. The description does not state the return format, the top-level-versus-recursive counting behavior, or which parameter to supply, so an agent lacks enough context to invoke the tool confidently.

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

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

Schema coverage is 100%, so the high-coverage baseline of 3 applies. The description adds no parameter-level guidance and does not clarify which of the many optional parameters should receive the JSON object, but the schema descriptions already define 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 names a specific verb and resource: count keys in a JSON object. The second sentence clarifies a key semantic, values are discarded. It does not explicitly differentiate this from sibling tools such as validate-json, so it misses the top score.

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 by the description: invoke it when a key-count of a JSON object is needed. However, it provides no explicit guidance about when not to use it or which sibling tools are alternatives, so the agent must infer the boundary.

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 usefully discloses that query strings and fragments are dropped, which is a meaningful behavioral trait beyond simply naming the tool. With no annotations provided, however, it does not clarify whether this tool makes a network request, whether HTTPS is required, or whether there are 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?

Two concise, front-loaded sentences with no filler. The first sentence states the core purpose and the second adds a useful exclusion, making the description easy to process 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?

The tool has 9 parameters and no output schema, yet the description only covers URL components. It does not explain which parameter to pass, why other parameters exist, the exact return shape, or constraints like HTTPS-only URLs, so an agent may not be able to invoke it correctly from the description alone.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds little parameter-level meaning beyond the schema, and it does not clarify how the many unrelated-looking parameters relate to URL normalization, though each parameter does have its own schema 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—'Return origin, host, and path for a URL'—with a clear resource and result. It is easy to understand what the tool does, though it does not explicitly differentiate itself from sibling tools like domain-shape 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?

Usage is implied: use this tool when you need the origin, host, or path of a URL. However, there is no explicit guidance about when not to use it or which sibling tools are alternatives, leaving some routing ambiguity.

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 behavioral burden. It usefully discloses that no browser is launched, which prevents a likely misconception. However, it does not clarify whether a network request is made, what 'opened' means, whether any side effects occur, or what the response format is.

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

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

Two short sentences deliver the core purpose and the key clarifying caveat with no filler. The information is front-loaded and every word earns its place.

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

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

With no annotations and no output schema, the description is too thin for a tool with 9 optional parameters. It does not explain the return value, whether any parameter is expected, or how the non-URL parameters such as city, json, and zone relate to the URL check. An agent would have to infer important calling details.

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 optional parameters already has a meaningful description. The tool description adds no parameter-level detail, 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 a specific verb and resource: it checks whether a URL can be opened. The phrase 'No browser is launched' directly distinguishes this tool from browser-based URL checks such as browser-url-ok, which is important given the playwright name.

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

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

The 'No browser is launched' caveat implies when this tool might be preferred over a browser-launching alternative, but the description does not explicitly name alternatives or state when-not-to-use it. Usage context is present but 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?

With no annotations, the description carries the full behavioral burden. It does disclose that the query is 'discarded,' which is useful, but it does not mention what is returned, whether there are side effects, or how the tool behaves with the other eight parameters 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 only two short sentences, front-loads the primary action, and contains no filler. Every phrase earns its place, and the key behavioral note about discarding the query is included.

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

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

For a tool with no output schema, no annotations, and nine optional parameters, the description is too sparse. It does not explain the return value, the purpose of the other schema properties, or why they are present. An agent could easily call it with the wrong parameter or expect a different result.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds little beyond the schema, repeating the 'discarded' behavior for the query parameter. It does not clarify why nine parameters exist or which one represents 'a search query,' though the schema's `query` description is clear.

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 verb and resource: 'Count characters in a search query.' This is specific enough to distinguish it from sibling shape/validation tools like wiki-title-ok or domain-shape. It could be slightly stronger by explicitly naming the `query` parameter and the numeric return value.

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 memory-key-count or think-steps. The description only states what it does, leaving the agent to infer the appropriate use case without any contextual or exclusionary signals.

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 says the tool is a 'catalog' but does not state whether it returns a list, whether parameters affect the result, or whether it has side effects. It is not contradictory, but it is nearly behavior-free.

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 tight sentence with no wasted words and is front-loaded. However, it is under-specified rather than optimally concise; important operational context is absent.

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, a one-line label is grossly insufficient. The description does not explain what the tool returns, how parameters relate to the catalog, or what the agent should expect when invoking 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 schema already documents each parameter's meaning and side effects. The description adds no parameter-level information, but this is acceptable at the baseline level because the schema carries the load.

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

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

The description clearly identifies the resource: a short catalog of common HTTP status codes. However, it is a noun phrase rather than a verb-led action statement, and it does not explicitly distinguish this from siblings 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?

There is no guidance on when to use this tool versus alternatives, no stated context, and no exclusions. The only usage signal is implied by the word 'catalog,' which is not enough to route an agent reliably.

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. 'Prompt discarded' explicitly reveals a non-obvious behavior: the tool returns a fixed result and does not use the provided inputs, despite having nine optional parameters. This prevents the agent from expecting prompt-dependent output. There are no destructive side effects or external effects to disclose.

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 terse sentences with the core purpose front-loaded and a behavioral caveat in the second sentence. Every word earns its place; there is no redundant phrasing 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, fully documented parameters and no output schema, the description communicates the essential contract: a fixed three-step template is returned and the prompt is ignored. It could name the three steps or explicitly note that an empty call is sufficient, but the schema already marks every parameter as optional and discarded. Overall this is adequate for such a simple tool.

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

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

The schema provides 100% description coverage for all nine parameters, and each parameter description already states that the value is discarded after a check. The tool description adds no per-parameter meaning beyond what the schema provides, so the schema carries the burden. Baseline 3 applies.

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

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

The description states a concrete verb ('Return') and a concrete resource ('a three-step thinking template'), so the core purpose is identifiable. 'Prompt discarded' further clarifies that the tool ignores input, which helps distinguish it from the sibling utility tools that analyze inputs. It could be more specific about what the template contains, but the purpose is not vague or tautological.

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 of the siblings, no stated use case, and no exclusions or prerequisites. The agent must infer appropriateness solely from the name and the fact that a template is returned. This is minimal 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 provided, so the description must carry the full behavioral burden. It mentions the core read-only behavior but does not disclose what happens with an invalid timezone, whether any side effects occur, or that the many unrelated schema parameters are effectively ignored. The description also sits awkwardly against the schema, which exposes many irrelevant fields.

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, focused sentence with no filler. It is front-loaded and 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 schema contains nine optional parameters, most of which are tangential to the tool's stated purpose, and there is no output schema or annotations. The description does not address this mismatch, nor does it describe the return format or error behavior. An agent needs more guidance to confidently 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?

All nine parameters already have descriptions in the schema, so schema coverage is 100%. The description adds very little beyond echoing the timezone parameter's purpose and does not clarify that the other eight parameters are not relevant to this tool, leaving room for misinvocation.

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 returns the current time for a named IANA timezone, which is a specific and recognizable operation. It distinguishes itself from siblings like utc-time (which does not take a timezone) and iana-zones (which lists 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 use case is implied by the description: use this when you need current time in a named IANA timezone. However, there is no explicit statement about when not to use it, nor any reference to alternatives such as utc-time, so an agent is left to infer the selection criteria.

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

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

There are no annotations, so the description must carry the burden of behavioral disclosure. It does not state that all input parameters are discarded/ignored, nor does it confirm that this is a stateless, side-effect-free operation. The schema hints at 'discarded' behavior, but the description itself is silent.

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 exceptionally brief and front-loaded, with no filler or redundant wording. Every word contributes to the core meaning.

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

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

Despite the tool being simple, the description ignores the substantial input schema and never explains that the parameters are irrelevant to the result. With no annotations and no output schema, an agent would be confused about how the nine inputs relate to 'Current UTC timestamp.'

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 provides descriptions for all nine parameters, so schema coverage is 100%. The description adds nothing about parameters, but the baseline of 3 applies because the schema already documents each parameter.

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

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

The description 'Current UTC timestamp' clearly states the tool's core behavior: it returns the current time in UTC. It is specific about the resource (UTC timestamp) and sets it apart from timezone-related tools, though it doesn't explicitly name a 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?

The description gives no guidance about when to use this tool versus alternatives like timezone or iana-zones. It also does not clarify why the input schema contains nine seemingly unrelated parameters or whether they should ever be 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?

The description adds one behavioral detail: 'The body is discarded,' implying no persistent side effects. However, with no annotations and no output schema, it fails to disclose the return value, error behavior, or what 'valid' means; it also does not clarify whether any of the nine schema parameters are preserved or checked beyond JSON validity.

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 short sentences with no filler, and the primary purpose is front-loaded. It earns conciseness credit, though the terseness contributes to some of the ambiguity around 'body.'

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

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

For a tool with no annotations and no output schema, the description is incomplete: it does not specify which parameter carries the body, what the successful or failed response looks like, or whether validation is strictly syntactic. The schema's nine optional parameters make this gap more significant, as an agent cannot tell which parameters are actually relevant.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself adds no parameter-level meaning and never maps 'body' to the likely 'json' parameter. The schema's 'json' property description compensates somewhat, but the description does not help an agent select among the many unrelated optional parameters.

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

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

The description states the specific action ('Check whether a body is valid JSON') and the resource ('body'), making the core purpose clear. However, it does not distinguish validate-json from sibling format/shape checkers such as file-path-ok or wiki-title-ok, and the term 'body' is left 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?

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. The description simply states what the tool does, leaving an agent to infer the appropriate calling context from the tool name and generic verb.

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 states the data source and implies a read-only weather lookup. It does not disclose output units, error behavior, external network dependency, rate limits, or the fact that the input is discarded after the call.

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

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

The description is a single short sentence with no filler and the key information is front-loaded. It is concise and easy to parse, though the brevity contributes to completeness problems rather than conciseness problems.

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 9-parameter schema is highly confusing for a weather tool, with many unrelated parameters and no guidance on which one to supply. There is no output schema and no annotations, so the one-sentence description leaves an agent without enough context to reliably invoke the tool among 27 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 schema already explains each parameter, earning a baseline of 3. The description adds no real semantic value beyond reinforcing that 'city' is the relevant parameter for weather, and it does not explain why the other eight parameters are present.

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 indicates the tool provides 'Current temperature for a city via Open-Meteo,' which identifies the domain and resource. It lacks an explicit verb like 'get' or 'fetch,' but the intent is obvious and it is distinguishable from sibling tools such as geo-hint or utc-time.

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

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

There is no when-to-use or when-not-to-use guidance, and no alternatives are mentioned. The only contextual detail is the data source 'Open-Meteo,' which does not help an agent decide between this tool and related hints. It is not misleading, but it provides virtually no usage 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 to rely on, the description correctly takes on the safety/behavior burden by stating the operation is limited to HTTP status and content type and that the body is discarded. It does not mention redirects, timeouts, or method semantics, but the core non-destructive behavior is clear.

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 result ('HTTP status and content type') is front-loaded and the key limitation ('Body discarded') is stated immediately after. 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?

A 9-parameter, 0-required, no-output-schema tool with no annotations needs more context than this. The description does not explain the relationship between the URL fetch and the unrelated optional params, what happens with no arguments, or the expected return shape.

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 explains every parameter, including which values are discarded. The tool description adds no parameter-level meaning and does not clarify why url, feed, host, json, path, zone, query, etc. all belong to one HTTP-status 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 names a concrete resource (public URL) and the two outputs (HTTP status, content type), and explicitly says the body is discarded. It is specific enough to show what the tool does, though it does not distinguish web-fetch from siblings like fetch-status or normalize-url.

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

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

There is no guidance about when to choose web-fetch over fetch-status, browser-url-ok, normalize-url, or the other shape-check siblings. The only implicit cue is the qualifier 'public URL', which weakly suggests it is for unauthenticated fetches.

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, and 'Title discarded after the call' is a useful statelessness hint. However, it does not disclose the return value, error behavior, or whether an actual network lookup is performed, and the 'title' concept never appears 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 two short sentences and front-loads the main action with a brief behavioral note. It is concise and easy to parse, though the second sentence is somewhat redundant with the repeated 'discarded' language in the schema descriptions.

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?

Even for a simple existence-check tool, the description is incomplete: it provides no mapping from the stated 'title' to any schema property, no output/return information, and no annotation coverage. An agent cannot reliably call this tool based solely on the provided definition.

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's core input, the Wikipedia title, is not present as a property in the input schema. The schema documents ref, url, city, feed, host, json, and path, but none is mapped to the title being checked, leaving an agent unable to determine how to invoke the tool. This is a critical semantics failure.

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 ('Check') and resource ('whether a Wikipedia title exists'), making the core purpose immediately clear. It does not distinguish from sibling tools, so it does not earn a 5. The missing 'title' parameter is a parameter-mapping problem rather than a purpose-clarity problem.

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?

'Check whether...' implies a validation/existence use case, but the description gives no explicit when-to-use or when-not-to-use guidance. It does not mention alternatives or warn against using a sibling like web-fetch or normalize-url for the same need.

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