Currency ZAR

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

With no annotations, the description carries the behavioral burden. It discloses useful behaviors: what it returns and that task text is discarded. However, it does not state side effects, authorization needs, external call behavior, or rate limits; 'Find' only implies a read-only operation.

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

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

The description is three short sentences with no filler. It front-loads the core purpose, then lists outputs, then adds a relevant data-handling note. 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 9 optional parameters, no required parameters, no output schema, and no annotations, but the description does not explain what input to supply, how the parameters relate to finding a Monid gateway, or what 'remote MCP hops' means. An agent would likely be unsure whether to pass url, query, or no arguments at all.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning beyond the schema, and the schema's own descriptions are often discard-oriented, but the tool description is not required to compensate when coverage is already high.

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 ('Find a public pay-per-call tool gateway (Monid)') and lists what it returns: CLI setup, how-it-works, skill file, and remote MCP hops. This goes beyond a tautology and generally distinguishes it from the sibling utility/checker tools, though it does not explicitly contrast with any of them.

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

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

No guidance is given for when to use this tool versus alternatives. The siblings include many URL/shape/validation tools, but the description never says when agent-tool-index should be preferred or what scenarios it is not for.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does reveal one useful behavior ('No browser is launched'), but it says nothing about whether a network request is made, timeouts, errors, authentication, side effects, or what result is returned. This is too thin for a tool with no annotation coverage.

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

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

The description is two short sentences with no filler. The core purpose is front-loaded, and the key behavioral caveat follows immediately. Every word earns its place.

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

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

The tool has 9 optional parameters, no output schema, and no annotations, yet the description only covers the general purpose and one behavioral constraint. It doesn't explain how the many 'discarded' parameters relate to the URL check, what a successful check looks like, or how to interpret failure. For an agent selecting and invoking this tool, this is incomplete.

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

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

The schema covers 100% of parameter descriptions, so the baseline is 3. The description adds no parameter-level meaning beyond what the schema already provides, but it also doesn't need to because each parameter is documented. There is no added semantic value, but no gap 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 states a specific action and resource: 'Check whether a URL can be opened.' The explicit 'No browser is launched' also helps distinguish it from browser-driven siblings like playwright-url-ok. However, it doesn't clarify what 'opened' means operationally (e.g., HTTP fetch, DNS resolution, status-code check), so it falls just 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 'No browser is launched' statement implies a when-not condition: use this when a lightweight URL availability check is sufficient and a real browser launch is not needed. But it never names alternatives or states explicit conditions for choosing this tool over normalize-url, fetch-status, or playwright-url-ok.

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

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

No annotations are present, so the description must carry the behavioral burden. It only says 'Expression discarded,' which hints at no retention, but it does not state whether evaluation returns a result, whether it is read-only, or what happens on invalid input. The schema also never defines where the expression lives, so the disclosed behavior cannot be acted on reliably.

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, and the core operation is front-loaded. As far as brevity goes, it is exemplary.

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

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

This tool has nine parameters, no annotations, and no output schema, yet the description does not explain return values, parameter mapping, error behavior, or invocation intent. An agent cannot reliably select or call this tool from this 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 input schema already describes all nine parameters at 100% coverage, so the baseline would be 3. But the tool description introduces an 'expression' concept that appears nowhere in the schema, and additionalProperties is false, so passing 'expression' would fail. This actively misleads rather than adding semantic 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 names a specific operation ('Evaluate a+b style arithmetic'), so the basic purpose is understandable. However, it does not map to any of the nine schema properties, and there is no 'expression' input among them, leaving an agent uncertain what to actually pass. It also does not distinguish itself from sibling shape-checking tools.

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

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

There is no guidance about when to use this tool versus any alternative. The sibling list includes many evaluator/checker tools, but the description gives no condition, context, or exclusion that would help an agent choose calc-eval.

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

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

With no annotations, the description must carry behavioral disclosure. It does reveal one useful trait: 'Page content is not stored.' But it does not say whether the tool makes an HTTP request, follows redirects, validates the URL, or has any rate limits. This is adequate but 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?

Two sentences, front-loaded with the core behavior and output fields. 'Page content is not stored' adds meaningful privacy context without padding. 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 a 9-parameter schema, no output schema, and no annotations, this description is too thin. It does not explain which inputs actually influence the returned host/scheme/status, which are discarded, or whether url is required. An agent needs more context to invoke this 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?

All 9 parameters have schema descriptions, giving 100% schema coverage, so the baseline is 3. The tool description adds no real parameter-level meaning beyond mentioning 'a URL,' and it does not clarify how the unrelated-looking parameters such as city, json, host, and feed relate to the stated purpose.

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

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

The description clearly states a specific verb and resource: 'Return host, scheme, and HTTP status for a URL.' This gives an agent a concrete idea of the tool's output. However, it does not differentiate this tool from closely related siblings like fetch-status or normalize-url, so it falls short of a 5.

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

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

There is no guidance about when to use this tool versus alternatives. 'Page content is not stored' hints at a privacy angle but is not framed as a usage condition or alternative-to-sibling rule. An agent is left to infer when citation 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?

The description adds a useful behavioral guarantee: 'No identifiers are retained', which aligns with the schema notes that values are 'discarded after the check'. However, with no annotations present, the description does not disclose whether the tool performs network calls, requires auth, or has other side effects, so the behavioral picture 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 brief and contains no filler: one sentence states the purpose and one states a privacy guarantee. However, for a tool with nine optional parameters and no output schema, it is undersized and does not provide enough structured context to be considered 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 and no output schema, the description must clarify what the classification result looks like and how to choose among the many heterogeneous optional inputs. It does neither, so an agent cannot reliably know what return value to expect or when to prefer this tool over the specific sibling shape-check tools.

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

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

Schema description coverage is 100%, so the baseline is 3; each parameter already has a meaningful description such as 'Git ref name; discarded after the shape check'. The tool description adds no selection rules about whether parameters are alternatives or how many should be supplied, but the schema carries the individual parameter semantics.

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

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

The description names a verb ('show') and an object ('how this request is classified'), so it is not a tautology. But it never defines what classification means, what 'this request' refers to, or how it relates to the tool's name 'compatibility', and it does not distinguish it from sibling shape-check tools. This is a clear but vague purpose.

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

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

There is no guidance about when to call this tool instead of any sibling such as domain-shape, normalize-url, validate-json, or file-path-ok. No prerequisites, exclusions, or alternative-selection cues 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, the description carries the behavioral burden. It is usefully transparent that the tool does not provide WHOIS/ownership data, but it does not disclose behavior for invalid hostnames, normalization, multiple inputs, or the exact return shape beyond 'labels.'

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to stating the action or an important exclusion.

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

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

The tool exposes 9 optional parameters and has no output schema, yet the description only explains the hostname-splitting case. It does not explain why ref, url, city, feed, json, path, zone, and query are present or which invocation the agent should use, leaving the definition incomplete.

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

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

Schema coverage is 100%, so the schema already documents every parameter, including which values are discarded. The description adds little parameter-level meaning beyond mapping to the 'host' field.

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 ('split') and a specific resource ('hostname'), and it states the output is labels. It also scopes out WHOIS/ownership data, but it does not explicitly distinguish this tool from siblings like normalize-url or github-repo-shape.

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

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

There is no guidance on when to choose domain-shape over the many sibling shape/url/validation tools, and no exclusion conditions are provided. The core action is clear, but the description leaves the selection decision entirely to the agent.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does state the HTTP method (HEAD) and that only status is returned, but it does not explain that all parameters are optional, what happens when multiple or no parameters are supplied, which inputs are discarded, or what the response format actually 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?

The single sentence is concise and front-loaded, with no wasted words. But given the nine-parameter schema and missing output schema, this level of brevity crosses into under-specification; it is not enough structure to guide invocation.

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

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

The description is incomplete for the actual tool complexity. There is no output schema, no annotations, nine optional parameters, no required parameters, and no explanation of the relationship between the description and the schema. An agent cannot reliably infer what to pass or what status result 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?

Although schema description coverage is 100%, the description does not map 'public URL' to the url parameter, and the url parameter's own description ('normalize or cite') conflicts with the stated HEAD-status behavior. The other eight parameters are left unrelated to the described purpose, so an agent cannot confidently decide which parameter 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 names a specific action and output: HEAD a public URL and return status only. However, the input schema reveals nine optional parameters covering unrelated inputs (ref, city, json, path, zone, query), so the stated purpose does not match the actual invocation surface. It also does not differentiate this tool from sibling URL/status tools such as browser-url-ok or playwright-url-ok.

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

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

No explicit when-to-use or when-not-to-use guidance is given, and no alternatives are named. The only implied use is 'when you need just the status of a public URL,' but the agent is left to guess how this compares to web-fetch, browser-url-ok, playwright-url-ok, or normalize-url.

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

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

With no annotations, the description carries the full burden for behavioral disclosure, but it only mentions 'Path discarded'—a detail already present in the path parameter's schema description. It doesn't disclose whether the tool validates, normalizes, returns a result, or has side effects, so the agent is left with insufficient behavioral context.

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

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

The description is very short, front-loaded with the main action, and contains no filler. Both sentences are purposeful, though the brevity leads to under-specification, which is better penalized in other dimensions.

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

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

For a tool with 9 parameters, 0 required, no output schema, and no annotations, this description is far too incomplete. It addresses only the Figma URL case and ignores the other accepted inputs, nor does it explain what the agent should expect as output, making it hard to select or invoke the tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds minimal value beyond the schema, only hinting that the 'url' parameter is central for Figma parsing. It does not clarify how the other eight parameters (ref, city, feed, host, json, etc.) relate to the tool's purpose, but the schema descriptions themselves are already informative.

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 ('Parse a Figma file URL') and a distinguishing behavior ('Path discarded'), giving a clear verb and resource. However, it doesn't explicitly link to the tool's likely 'shape' validation purpose or differentiate from sibling URL tools such as normalize-url 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 on when to use this tool versus the many similar sibling tools (e.g., normalize-url, browser-url-ok, domain-shape). The description does not mention any conditions, alternatives, or exclusions, leaving the agent to infer usage from the name and schema alone.

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

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

With no annotations provided, the description must carry the full behavioral burden. It does disclose 'No disk access,' which is a meaningful safety guarantee, but it does not explain what 'safe' means, how the check behaves, what it returns, or how it handles the many non-path inputs 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 with no filler and front-loads the purpose before the safety caveat. It is appropriately concise, though the brevity contributes to under-specification rather than being a flaw in structure.

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, this description is not complete enough. It fails to clarify whether all parameters are validated, which inputs are alternatives, what the output shape is, and what 'safe' means in practice.

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 structured definitions already document each parameter, including discard behavior and intended use. The description adds no parameter-level meaning beyond the word 'path,' which aligns with the schema's 'File path to check' parameter, 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 names a specific verb and resource ('Check whether a path looks safe') and adds a useful safety qualifier ('No disk access'), so the core idea is understandable. However, it does not explicitly say 'file path' and it ignores the tool's broad input schema, which accepts nine unrelated parameters such as url, json, host, and city. This creates ambiguity about whether the tool validates only the 'path' parameter or all of them.

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

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

The description provides no guidance on when to use this tool instead of siblings like browser-url-ok, normalize-url, or wiki-title-ok. There is no mention of alternatives, exclusions, or the kind of path for which this check is appropriate.

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

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

With no annotations, the description must carry the behavioral burden. It reveals only that Open-Meteo is used; it does not say whether a network call is made, what response shape is returned, how failures surface, or which input is actually consumed.

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 filler. It loses a point only because it is too terse to carry the needed semantic 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?

For a tool with nine heterogeneous parameters and no output schema, this description is under-specified. An agent cannot tell which parameter to populate, what the tool returns, or how it behaves when the place is unknown.

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

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

Although the schema documents all nine parameters (100% coverage), the description does not map 'a place' to the city parameter or any other parameter. The schema's city description says 'public weather hint' and 'discarded after the call,' which conflicts with the geo-lookup purpose.

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

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

The description names a concrete result — latitude and longitude for a place — and the data source, Open-Meteo. It does not, however, contrast with weather-hint or other sibling tools, so it earns a 4 rather than a 5.

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

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

No guidance is given about when geo-hint is preferable to weather-hint, timezone, or other location-related tools, and no exclusions or prerequisites are stated. The only implied use is whenever coordinates for a place are needed.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states only that it parses owner and repo, but does not describe the return format, error behavior, handling of non-GitHub URLs, or whether the input URL is normalized.

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

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

The description is a single, front-loaded sentence with no filler. Every word 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 and no annotations, and the description does not specify the result shape or failure behavior. Additionally, the nine-parameter schema includes many fields irrelevant to the stated GitHub-URL parsing purpose, creating ambiguity about which inputs are actually used.

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

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

The schema provides descriptions for all parameters, so the baseline is 3. The description adds GitHub-specific context for the 'url' parameter, but it does not clarify why the schema contains many unrelated parameters such as 'city', 'feed', and 'host'.

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 ('parse'), a specific product ('owner and repo'), and a specific source ('GitHub URL'). This clearly distinguishes the tool from sibling shape tools like jira-key-shape, figma-url-shape, and domain-shape without needing to inspect their schemas.

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 description: use this when you have a GitHub URL and need to extract the owner and repository. However, there is no explicit guidance about when not to use it or which sibling alternative to choose for related URL tasks.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only discloses that titles are discarded, but it does not state whether a live network fetch occurs, what the return value looks like, how failures are handled, or which of the nine declared inputs are actually used. This leaves too much unspecified.

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

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

The description is two short sentences, front-loads the core action, and contains no filler. 'Titles discarded' is a compact and useful clarification that 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 nine optional parameters, no output schema, and no annotations, so the description should explain how to invoke it and what result to expect. It only says to count HN stories and discard titles, never stating whether any parameter is needed, which one, or what the count response looks like. The generic input schema makes this omission especially confusing.

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

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

The input schema already describes all nine parameters, so the baseline is 3. The tool description adds only 'Titles discarded,' which largely echoes the feed parameter's schema description and does not clarify why unrelated parameters like city, zone, or json exist or which parameter should be supplied for the HN count.

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.' It also adds a delimiting behavioral note, 'Titles discarded,' which clarifies that the result is a count, not story content. This clearly distinguishes it from sibling fetch and shape-checking tools.

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

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

The description provides clear context: this is the tool for counting current Hacker News front-page stories. It does not explicitly name alternatives or exclusions, but no sibling tool appears to overlap with this purpose, so the context is sufficient for an agent to know when to 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?

With no annotations, the description must disclose behavior, but it does not. It never states what executing the tool does, whether it returns a list, what side effects exist, or that many input parameters are discarded, despite the schema showing that several parameters are 'discarded after' checks.

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

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

The description is short and front-loaded, but it is under-specified rather than concise. A single noun phrase does not earn its place because it fails to convey the tool's purpose or 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?

The tool has 9 optional parameters, no annotations, and no output schema, yet the description provides no information about return values, invocation behavior, or how it relates to the timezone/utc-time siblings. This is far too little context for an agent to select and call the tool correctly.

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

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

Schema description coverage is 100%, so each parameter is documented in the schema. The tool description adds no parameter-level meaning, but the schema already provides baseline clarity, so a 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 is a noun-phrase fragment, 'Common IANA timezone names for clock calls,' rather than a statement of what the tool does. It identifies a resource and a loose context but lacks any verb or action, so an agent cannot tell whether this tool returns names, validates them, or does something else.

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

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

The phrase 'for clock calls' hints at a use case involving timezone-related operations, but there is no explicit guidance on when to use this tool versus siblings like timezone or utc-time. No when/when-not conditions or alternatives are mentioned.

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

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

With no annotations provided, the description carries the transparency burden. It does disclose a meaningful behavior: only group counts are returned, not the full robots.txt body. Still, it is silent about error handling, redirects, network failure, and what 'group counts' includes, leaving important behavioral expectations unspecified.

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

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

The description is a single front-loaded sentence with no filler. Every word contributes: the resource is named, the operation is clear, and the output limit is stated.

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, the description is too thin. It fails to specify which parameter identifies the robots.txt URL or host, and it does not describe the shape of the returned group counts or failure behavior, so an agent cannot reliably invoke it correctly.

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

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

Although the schema descriptions cover all nine parameters, they are generic and none of them mentions robots.txt. The tool description never maps the robots.txt target to a specific parameter, and with zero required parameters the agent cannot tell whether to use 'url', 'host', or another input to select the resource.

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

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

The description names a specific verb and resource ('Fetch a public robots.txt') and a precise output constraint ('return group counts only'). This makes the tool's purpose unmistakable and differentiates it from generic fetchers like web-fetch, which would return page content.

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 purpose: use this when you need group counts from a public robots.txt. However, there is no explicit when-to-use versus alternatives, no exclusions, and no mention of how this differs from sibling utilities such as web-fetch, fetch-status, or normalize-url.

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

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

No annotations are provided, so the description must carry the behavioral burden. It discloses only that the key is discarded, but does not state whether the check is read-only, local, what happens on invalid shape, or what the tool returns. This is insufficient for a tool with zero annotation coverage.

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

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

The description is two short sentences with the main action front-loaded and the disposal behavior separated cleanly. There is no filler; the brevity, however, contributes to the overall incompleteness rather than being a model of concise 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 9 optional parameters, no annotations, and no output schema, this description is far too thin. It does not specify which parameter to use, what the tool returns, what a valid Jira key shape looks like, or how errors are reported. An agent cannot correctly invoke this tool 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?

The description refers to a 'key,' but the input schema has no 'key' property. The closest parameter, 'ref,' is described as a 'Git ref name,' which conflicts with a Jira issue key. With 9 optional parameters and no required ones, the agent cannot reliably determine which parameter should hold the Jira key.

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

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

The description states a specific action and resource: 'Check a Jira issue key shape.' This distinguishes it from sibling shape tools like github-repo-shape and domain-shape. However, it does not define what 'shape' means or what validity criteria are used, so it stops short of full 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 sibling tools, no alternatives mentioned, and no indication of prerequisites or typical invocation context. The intended usage is only implied by the tool name and resource.

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, but it only discloses that the body is discarded. It does not explain network behavior, how multiple supplied parameters are handled, potential failure modes, or what the returned HTTP status actually represents.

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, but it under-specifies a tool with nine optional parameters and a broad input schema. This brevity is closer to under-specification than effective compaction.

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 incomplete for a nine-parameter tool with no annotations and no output schema. It only addresses a library-docs-URL case and leaves unclear how the other fields relate to invocation or what output an agent should expect beyond an HTTP status.

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 each field's description already explains its meaning and discard behavior, such as 'Git ref name; discarded after the shape check.' The tool description adds no parameter semantics 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 says 'HTTP status for a public library docs URL,' which names an operation and target, but the input schema accepts nine unrelated optional fields (city, feed, json, query, etc.) and the name 'lib-docs-hint' is ambiguous. It also does not distinguish this tool from sibling status checkers 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 when-to-use guidance, no mention of alternatives, and no exclusion criteria beyond the implied docs-URL context. 'Body discarded' hints at behavior but does not help an agent decide when to use this tool instead of the many related sibling tools.

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

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

With no annotations, the description carries the burden. 'Values discarded' usefully reveals that the tool is read-only with respect to the value data, and 'count' implies no mutation; however, it does not disclose the return shape, behavior on invalid JSON, or whether nested keys are included.

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

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

The definition is only two short sentences with an action verb first and no filler. It is easy to parse, though extremely terse.

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 lack of annotations and output schema raises the bar, and the tool has nine optional parameters with no required one. The definition never tells the agent which parameter holds the JSON text, what the count refers to (top-level vs recursive), or what is returned; that makes it incomplete despite the short clear 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?

Schema coverage is 100%, so the baseline applies: the description need not repeat every parameter. Still, the only likely candidate for the 'JSON object' is the json parameter, and that field is described in the schema as 'validate', not 'count'; the description never names the parameter that should actually be supplied.

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

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

States a concrete operation (count keys) on a specific resource (a JSON object) and adds a behavioral qualifier (values discarded). It is unambiguous at a high level, but it does not name the relevant schema parameter or distinguish itself from validate-json explicitly, so it stops short of top marks.

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?

Use is only implied by the verb 'count': an agent would reach for it when it needs a key count. There is no explicit when-not-to-use statement, no mention of validate-json as the choice for merely checking validity, and no guidance 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?

The description adds a useful behavioral detail: query and fragment are dropped. Since no annotations are provided, this partially compensates for the lack of structured safety or side-effect hints. However, it does not disclose how invalid URLs are handled, whether only the 'url' parameter is used while others are ignored, or any other side effects.

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

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

The description is extremely concise: two sentences, with the primary function stated first and a key behavioral caveat immediately after. There is no redundant wording or low-value 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?

Given nine optional parameters, zero required parameters, no annotations, and no output schema, the description is too sparse to fully support correct invocation. It does not explain how the returned origin, host, and path are formatted, whether the other parameters are ignored, or what happens with invalid input.

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

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

Schema description coverage is 100%, so the baseline is 3. The description clarifies that the URL's query and fragment are dropped, but it does not help an agent decide which of the nine optional parameters are relevant. It adds no parameter-level meaning beyond what the schema already provides.

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

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

The description clearly states the tool's verb and resource: 'Return origin, host, and path for a URL.' It also specifies a key behavior, dropping query and fragment. However, it does not explicitly distinguish itself from sibling URL-related tools such as browser-url-ok or domain-shape.

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

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

No guidance is provided about when to use this tool versus the many sibling tools, nor are any alternatives named. The intended context must be inferred from the function name and general phrase 'for a URL,' so an agent has little support in choosing it over similar URL-handling tools.

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

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

With no annotations provided, the description carries the full burden of disclosure, but it only says no browser is launched. It does not state whether the tool makes a network request, follows redirects, mutates anything, or how 'opened' is determined, leaving important behavioral facts unstated.

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

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

Two short sentences contain the core purpose and the key caveat with no filler. The main action is front-loaded and the browser-related caveat is necessary given the playwright-url-ok name.

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

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

Despite concise wording, the definition is incomplete for a tool with 9 optional parameters and no output schema or annotations. It never explains what the tool returns, what qualifies as 'can be opened,' or how the unrelated-looking parameters like city, zone, and query fit into the call.

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

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

Schema description coverage is 100%, so the baseline applies; each parameter is already documented in the schema. The description itself adds no parameter-level detail, so it neither harms nor improves on the structured definitions.

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

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

The description states a specific action and resource: 'Check whether a URL can be opened.' The added 'No browser is launched' hints at a distinction from the sibling browser-url-ok, but it does not explicitly define what 'opened' means (HTTP reachability vs. link validity), leaving some ambiguity.

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

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

The note that no browser is launched implies this is the no-browser variant compared to browser-url-ok, so there is some implied usage context. However, it does not explicitly say when to prefer this tool over siblings such as fetch-status, normalize-url, or browser-url-ok, leaving the selection largely 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?

'Query discarded' is a genuine behavioral disclosure and is useful because no annotations are provided. However, the description does not clarify whether the operation is purely local, what side effects occur with the other optional fields, or what the return value 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?

Two short sentences, front-loaded with the action, with no filler. The discarded-input note earns its place as a meaningful behavioral signal.

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 no visible 'query' parameter, the description is too thin for confident invocation. It communicates intent but not the input contract or the expected return shape beyond an implicit character count.

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

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

The schema descriptions cover the listed parameters, which normally earns a baseline 3, but the description's central input — the search query — does not map to any property in the schema ('query' is absent; the listed properties are ref/url/city/feed/host/json/path). The description therefore adds no usable parameter guidance and leaves the agent unable to determine which field to populate.

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

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

The description states a specific verb and resource — counting characters in a search query — and this clearly distinguishes it from sibling validation/counting tools. It is concise and unambiguous about intent, though it does not map the 'search query' to a visible input parameter.

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 sibling tools such as memory-key-count or validate-json. There are no conditions, exclusions, or alternative-tool hints in the 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 burden of behavioral disclosure, but it only implies a static reference catalog. It does not state that parameters are ignored or discarded, whether any network or file access occurs, or what the output format 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, front-loaded sentence with no wasted words. It conveys the core idea efficiently.

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

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

The description is too thin for a tool with nine optional parameters, no output schema, and no annotations. An agent is left unsure whether any input is needed, why the parameters exist, or what the returned catalog looks like.

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

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

Schema description coverage is 100%, so each parameter already has a semantic description. The tool-level description adds no parameter meaning, which is acceptable under the baseline, though the presence of nine unrelated-looking optional parameters remains unexplained at the tool level.

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 and scope: a short catalog of common HTTP status codes. It lacks an explicit verb like 'returns' or 'lists', and it does not directly distinguish itself from sibling tools such as fetch-status, but the purpose is still readily understandable.

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 fetch-status, browser-url-ok, web-fetch, or other related siblings. The description gives no context, conditions, or exclusions, leaving the agent to infer the intended use case.

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

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

Annotations are absent, so the description carries the behavioral burden. The phrase 'Prompt discarded' does disclose that the incoming prompt will not be used, which is useful. It does not, however, clarify whether any of the nine schema parameters are honored or what side effects (none expected) 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 two short sentences with the main action front-loaded. It contains no filler, though 'Prompt discarded' is cryptic and could be clearer.

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

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

With no output schema, no annotations, nine parameters, and no explanation of the template structure, the definition is under-specified. An agent cannot tell what the returned template looks like or whether it needs to pass any of the parameters, despite schema hints that most are discarded.

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

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

Schema coverage is 100%, and each parameter already has a description, many explicitly noting it is discarded. The description adds no parameter-level meaning beyond what the schema provides, so the baseline score 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 first sentence identifies a specific action and deliverable: 'Return a three-step thinking template.' This clearly states what the tool produces, and the name think-steps aligns. However, it does not distinguish the tool from any sibling or describe what the template contains.

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

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

There is no guidance about when to call this tool instead of one of the many sibling tools. 'Prompt discarded' hints that the input is ignored, but it does not explain use cases or prerequisites. An agent is left to infer when a three-step thinking template is wanted.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states only that the result is the current time; it does not disclose whether the call is read-only, how invalid or missing zones are handled, whether network access is required, or what the returned value contains.

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

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

The description is a single front-loaded sentence with no filler, making it efficient and easy to parse. It is slightly too sparse to earn a 5, but it is appropriately concise for the core purpose.

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

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

For a simple lookup tool, the description plus the zone parameter description is minimally sufficient to guess the intended invocation. However, with zero required parameters, no output schema, no annotations, and a schema cluttered with unrelated fields, the tool would benefit from stating that zone is effectively required and what happens when it is omitted.

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

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

Schema description coverage is 100%, so the schema already documents all parameters; the description adds little semantic meaning beyond pointing to an IANA timezone. It also does not clarify that only the zone parameter is relevant among the nine unrelated schema properties, leaving the agent to infer the intended 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 phrase 'Current time in a named IANA timezone' clearly identifies the operation (return current time) and the resource (an IANA timezone), so it is not vague or tautological. It distinguishes implicitly from sibling tools like utc-time and iana-zones, but never names them explicitly.

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

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

The description implies when to use the tool: when a caller wants the current time for a specific IANA zone. However, it provides no when-not-to-use guidance or explicit alternatives, such as 'use utc-time for UTC or iana-zones for a list of zone names.'

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

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

With no annotations, the description must carry the behavioral disclosure burden. It only states the output and omits that all inputs are discarded, that the tool is side-effect free, and that it works without arguments. The schema's per-parameter 'discarded' notes give partial info, but the description itself is not 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?

The description is a single sentence with no filler, making it concise and front-loaded. It is efficient, though it uses its brevity to avoid addressing the param mismatch, which is more of a completeness concern than a conciseness one.

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 time-returning tool with seven unrelated optional parameters demands explanation, but the description leaves an agent uncertain whether arguments are required or meaningful. With no annotations or output schema present, the definition is not complete enough 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?

The input schema provides descriptions for all seven parameters, giving 100% coverage, so the baseline is 3. The description adds no parameter-level meaning and does not synthesize that they are effectively no-ops, but the schema already covers each individual field.

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 UTC timestamp, which is specific about the output. However, it does not explain the purpose of the seven input parameters or differentiate it from sibling tools like timezone and iana-zones, leaving some ambiguity.

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

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

There is no guidance about when to use this tool versus alternatives. It does not mention that all parameters are ignored, nor does it provide any context for when this should be selected over e.g. timezone.

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

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

With no annotations provided, the description carries the full behavioral burden, and it does disclose one meaningful trait: the body is discarded after the check. However, it omits important behavior such as what the tool returns, how invalid JSON is reported, and whether any side effects occur.

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

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

The description is two short, front-loaded sentences with no filler. The action is stated first, and the disposal behavior is added concisely in the second sentence.

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

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

The tool has no output schema and no annotations, yet the description never states what the tool returns or how a valid/invalid result is signaled. It also does not explain which of the nine optional parameters matter for the JSON validation beyond relying on the schema's own descriptions.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters. The description adds the 'body' terminology but does not clarify which schema parameter corresponds to the body, leaving that to the json parameter 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 uses a specific verb ('Check') and a precise target ('whether a body is valid JSON'), making the tool's core purpose immediately clear. It is also distinct from sibling validators like domain-shape or wiki-title-ok, which focus on different input types.

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

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

The purpose implies that the tool should be used when an agent needs to validate whether a body is valid JSON, but it gives no explicit when-to-use or when-not-to-use guidance. It does not name alternative tools or exclude scenarios.

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

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

No annotations are provided, so the description carries the full burden. It mentions Open-Meteo but not whether this is a live network fetch, what the response looks like, or that all inputs are discarded; the discard behavior appears only in the schema, not the description. This is insufficient for a tool with no output 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?

One short sentence, front-loaded with the core purpose and data source. It is efficient, though the brevity contributes to ambiguity about the tool's actual 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?

With nine optional parameters, no output schema, and no annotations, a one-sentence description is not enough. It does not explain which parameter to pass, what the return value is, or how this tool relates to the sibling hint tools.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level detail beyond naming a city, and the schema already documents each parameter, including 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 outcome ('current temperature for a city') and the data source (Open-Meteo), so an agent can tell this is a weather-related lookup. It does not explicitly distinguish it from geo-hint or explain why the schema contains many unrelated parameters, so it is clear but not fully disambiguated.

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 statement about when to use this tool rather than geo-hint, lib-docs-hint, or the other hint tools. The agent must infer from the name and description alone, so 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?

With no annotations available, the description carries the behavioral transparency burden. It does disclose a key behavior—the response body is discarded—which is valuable context for an agent deciding whether this tool can satisfy a content-extraction request. However, it does not address redirects, failures, timeouts, or the fact that the schema contains many seemingly unrelated optional 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 extremely concise: two short sentences with no filler. The primary outcome is front-loaded, and the body-discarded caveat is presented immediately. Every word earns its place.

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

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

The description is too thin for a tool with nine optional parameters, no annotations, and no output schema. It does not explain why the schema contains non-URL parameters or clarify which parameter an agent should supply to obtain the HTTP status and content type, leaving room for misinvocation.

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

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

Schema description coverage is 100%, so each parameter is already documented in the input schema. The tool description adds no parameter-level detail, but at this coverage level the schema carries the load, making the baseline 3 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 concrete observable outcome: HTTP status and content type for a public URL, and it explicitly notes that the body is discarded. This is specific enough to differentiate from content-fetching tools, though it does not explicitly distinguish it from similarly named 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?

The description provides no guidance about when to prefer this tool over alternatives, nor does it mention exclusions. The only implicit signal is that the URL must be public, but this is not developed into a clear when-to-use instruction.

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

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

With no annotations, the description must carry the behavioral disclosure burden. It only says the title is discarded after the call; it says nothing about network behavior, return values, error handling, or side effects.

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

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

The description is two short sentences with no filler, and the core purpose is front-loaded. It earns its length despite being under-specified.

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 annotations and no output schema, while the input schema has seven unrelated-looking parameters. A description that fails to connect any parameter to the stated purpose is severely incomplete for correct invocation.

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

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

The schema documents all seven parameters, so the baseline is higher, but the description adds no parameter mapping and references an entity, a title, that appears nowhere in the schema. An agent cannot determine which parameter supplies the Wikipedia title.

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: checking whether a Wikipedia title exists. However, it never ties that purpose to any of the seven input properties, and none of them is named 'title', so the actual behavior is materially unclear.

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

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

There is no guidance about when to use this tool versus the many sibling validation and hint tools, no exclusions, and no examples. The only implied trigger is needing a Wikipedia-title existence check, 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.