Currency SGD

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

With no annotations, the description carries the behavioral disclosure burden. It does disclose that task text is discarded and enumerates return contents. However, it does not mention whether the call is read-only, requires anything, or how the parameters affect behavior, 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?

Two tight sentences, front-loaded with the core purpose and followed by the key return information and discard warning. Every clause 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 lists return artifacts but never explains how to actually invoke the tool: which of the six heterogeneous parameters (ref, url, city, feed, host, json) is required, optional, or even relevant to finding a Monid gateway. With no output schema or usage hints, an agent cannot confidently choose a valid call 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?

The input schema provides descriptions for all six parameters, so coverage is 100%. The tool description itself adds no parameter-level meaning, which lands at the baseline 3 for fully documented schemas.

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

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

The description uses a specific verb ('Find') and names the resource ('public pay-per-call tool gateway (Monid)') and lists the concrete returned artifacts (CLI setup, how-it-works, skill file, remote MCP hops). It does not explicitly contrast with siblings, but the discovery/index nature is clear enough to distinguish it from the URL/status/shape utilities in the sibling list.

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 a clear context: use it when you need to locate a Monid gateway. It does not name alternatives or exclusion criteria, so it does not reach a 5, but the 'find a ... gateway' framing provides a usable selection signal.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose a key trait: no browser is launched. However, it does not explain whether a network request is made, what kind of checks are performed, or whether any side effects occur. The disclosure is helpful 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?

The description is appropriately short and front-loaded: 'Check whether a URL can be opened' comes first, and the clarifying constraint 'No browser is launched' follows immediately. It is not bloated, though it may be too sparse given the tool's many parameters.

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

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

The definition is incomplete for an 8-parameter tool with no annotations and no output schema. It does not state what 'ok' means, what the tool returns, or how the non-URL parameters are used. An agent cannot confidently call this tool correctly across its possible inputs based on 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?

The description adds no parameter-level detail beyond mentioning 'URL.' The input schema already provides descriptions for all eight parameters, so baseline 3 is appropriate. Still, the description does not clarify how parameters like ref, city, json, or path relate to the core 'URL can be opened' behavior, leaving semantic gaps.

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.' This is clear and the 'No browser is launched' clause distinguishes it at least from browser-launching tools. However, it does not explicitly differentiate it from siblings like fetch-status or normalize-url, and the meaning of 'can be opened' is left somewhat vague.

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. The phrase 'No browser is launched' is a behavioral constraint, not a selection rule, and no sibling tools or conditions are mentioned. An agent must infer the intended use case without explicit 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, the description carries the full burden of behavioral disclosure. It only says the expression is discarded, but does not state what is returned, whether inputs are stored, whether side effects occur, or what happens for unsupported inputs. The schema's many 'discarded after check' notes are not reflected in the description and further obscure behavior.

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

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

The text is very short and front-loaded, with no filler or repeated schema content. However, the brevity is under-specification rather than effective conciseness, because the description lacks the information needed to align the purpose with the nine-parameter schema.

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

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

This is a nine-parameter tool with no output schema and no annotations, so the description must explain what the tool does with inputs, what it returns, and when to use it. The two sentences cover none of that and even omit the required arithmetic operand. An agent cannot correctly invoke this tool based on the 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?

Schema coverage is 100%, yet none of the nine parameters corresponds to the advertised arithmetic expression. The description adds no mapping from 'a+b' to any field, and several schema descriptions ('search text', 'JSON text', 'file path') point to unrelated operations. This provides more confusion than value beyond the raw schema.

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

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

The description names a concrete operation ('Evaluate a+b style arithmetic'), but 'Expression discarded' muddles whether the tool returns a result or simply ignores input. The schema provides no expression parameter, so the stated purpose cannot be mapped to any field. It also does not meaningfully differentiate from the many sibling check/hint tools.

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

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

No when-to-use guidance, prerequisites, or exclusions are provided. There is no mention of alternatives or cases where a sibling tool such as validate-json, search-query-len, or normalize-url should be chosen instead. Use must be inferred entirely from the name and single 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It adds a meaningful trait by stating that page content is not stored, and it implies a network read operation by returning HTTP status. However, it omits other behaviors like rate limits, caching, auth, or error handling.

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 behavior and follows with a useful privacy statement, so 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 nine optional parameters and no output schema, yet the description only covers the URL case. It leaves unclear the role of the other parameters and the exact return format or error behavior, so an agent cannot confidently invoke it across all intended scenarios.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description adds little parameter-level meaning. The description identifies URL as the main input but does not clarify how the other optional parameters, such as city, json, or feed, relate to the stated output.

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 concrete outputs (host, scheme, HTTP status) for a URL, so the core function is clear. It does not explicitly distinguish itself from sibling tools like fetch-status or normalize-url, but it is not a tautology.

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

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

There is no guidance on when to use this tool versus alternatives such as fetch-status, normalize-url, or web-fetch. The privacy note 'Page content is not stored' hints at a use case, but no when-to-use or when-not-to-use conditions are given.

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 does disclose 'No identifiers are retained', which is useful, but it does not explain what the classification output looks like, whether any external calls are made, or what side effects occur for the seven accepted inputs.

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

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

The description is extremely short, but this reads as under-specification rather than conciseness. With seven optional parameters, many sibling tools, and no output schema, one purpose sentence and one privacy sentence are not enough for an agent to invoke 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?

There is no output schema and a large set of sibling tools, yet the description does not explain the classification output, the meaning of 'compatibility', or which inputs correspond to which classifications. An agent would have to guess at the intended behavior.

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

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

Schema description coverage is 100%, so each parameter already has a meaningful description about its purpose and discard behavior. The tool description adds no parameter-level insight, but the high schema coverage justifies the baseline score of 3.

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

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

The description says 'Show how this request is classified', providing a verb and object, but it does not explain what classifications exist, what 'request' refers to, or how the classification is determined. It is not a complete tautology, but it is vague and does not distinguish this tool from sibling classifier/shape 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?

No guidance is given about when to use this tool versus siblings like domain-shape, github-repo-shape, normalize-url, or validate-json. The only additional information, 'No identifiers are retained', is a privacy note rather than a usage condition.

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

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

The description discloses a useful behavioral trait beyond the schema: the tool performs no WHOIS or ownership lookup, which implies a local, read-only split operation. Given that no annotations are provided, this helps, but the description still does not mention that other schema parameters appear to be discarded or what the return shape 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 description is a single, front-loaded sentence with no filler; every word contributes to the core action and limitation. It is concise, though a second sentence clarifying the multi-parameter schema would have made it more complete.

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

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

With no annotations, no output schema, and a 9-parameter optional schema, the one-line description is insufficient to fully define the call contract. It does not identify which parameter to populate beyond the implicit 'host', does not describe the return value, and does not explain why unrelated parameters like city, json, path, and zone are present or ignored.

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

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

The input schema covers all 9 parameters with descriptions, so the baseline is 3. The description's 'hostname' maps naturally to the 'host' parameter, but it adds no additional parameter semantics such as precedence, formatting, or discard behavior beyond what the schema already states.

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

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

The description states a specific verb and resource: 'Split a hostname into labels', and adds a clear negative scope ('without WHOIS or ownership data') that distinguishes it from ownership/WHOIS lookups. It does not explicitly name a sibling alternative, so it is not a 5, but the core action is unambiguous.

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

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

The phrase 'Split a hostname into labels' implies when to use it, and the 'without WHOIS or ownership data' clause tells the agent not to expect ownership information. However, there is no explicit when-to-use vs. when-not-to-use guidance and no alternative tool is named, leaving some inference required.

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

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

With no annotations, the description carries the behavioral burden, and it does disclose the HTTP method (HEAD) and that the response is limited to status. It does not describe redirects, timeouts, errors, rate limits, or how the non-URL parameters are handled, which is a clear gap for a networked 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 single sentence is front-loaded and free of filler, which is good. However, for a tool with numerous optional parameters and no output schema, one sentence is not appropriately sized; it omits essential scoping information.

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

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

Given the tool's complexity, no annotations, and no output schema, the description is far from complete. It does not describe the return format beyond 'status only', does not say what happens when multiple parameters are supplied, and does not explain the domain of each parameter.

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 descriptions for all parameters with 100% coverage, so the baseline is met. The description itself only clarifies the url case and adds no organizing guidance about whether the other parameters are alternative modes, which keeps it at the minimum viable 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 states a specific action and result: HEAD a public URL and return status only. However, it is too narrow for the input schema, which exposes many unrelated optional parameters such as ref, city, feed, json, path, and query, and it does not distinguish this tool from sibling URL-checking tools like browser-url-ok, playwright-url-ok, or web-fetch.

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

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

There is no explicit when-to-use or when-not-to-use guidance. 'Return status only' weakly implies a lightweight alternative to full fetching, but the description never names alternatives or explains how to choose among the many optional parameters, leaving an agent to guess whether fetch-status is the right tool.

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

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

The description discloses one behavioral trait: 'Path discarded.' With no annotations provided, the description carries the full burden for behavioral disclosure. It does not state whether the operation is read-only, what the returned value looks like, what validation rules apply, or how invalid URLs are handled.

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

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

The description is very short and front-loaded: the core action appears first, followed by the relevant caveat. Every word earns its place. It is slightly under-specified, but for conciseness and structure this is effective.

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 output schema, and no annotations, this description is too sparse for reliable invocation. It does not explain what a successful parse returns, what 'shape' checking entails, which parameter matters, or what to do with the discarded path. An agent would need to infer too much.

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

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

The input schema has 100% description coverage, so the baseline is 3. The description adds no meaningful parameter-level detail beyond the schema, and it does not clarify which of the 9 parameters should be used as the Figma URL, though 'url' is the obvious candidate. No contradiction or new param insight is provided.

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: 'Parse a Figma file URL.' It clearly identifies what the tool operates on and adds a concrete detail that the path is discarded. However, it does not explicitly distinguish itself from sibling tools like normalize-url or browser-url-ok, so it stops short of a 5.

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

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

There is no guidance about when to use this tool versus alternatives such as github-repo-shape, jira-key-shape, or normalize-url. The intended use is only implied by the tool name and the phrase 'Figma file URL.' No exclusions or alternative routing are provided.

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

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

There are no annotations, so the description carries the behavioral burden. It does disclose 'No disk access,' which is a useful safety trait, but it does not explain what 'looks safe' means, whether there are any side effects, what the return value is, or why the input schema contains many unrelated 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 very short and front-loaded: the first sentence states the action, the second adds a safety constraint. Both sentences earn their place, though the brevity leaves important information unstated.

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

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

For a tool with 9 optional parameters, no output schema, and no annotations, the description is too terse. It does not define what makes a path 'safe,' which parameter should be provided, or what output shape to expect, leaving an agent uncertain about correct invocation.

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

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

Schema description coverage is 100%, and every parameter already has a description in the schema. The tool description adds no parameter-level meaning, so the baseline of 3 is appropriate even though the schema's parameter descriptions seem inconsistent with the stated path-checking 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: check whether a path looks safe, and adds a meaningful qualifier ('No disk access'). It does not explicitly differentiate this from sibling shape-check tools, but the name and phrasing make the core purpose 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?

The description gives no guidance on when to use this tool versus alternatives like normalize-url, browser-url-ok, or wiki-title-ok. It implies a validation/safety-check use case, but does not state when it is the right choice or when a sibling tool would be preferable.

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 full burden of behavioral disclosure. It only names the external service and the result type, but does not explain that most parameters are discarded, that the operation is read-only, what happens on invalid input, or what the exact return shape 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 description is a single front-loaded sentence with no filler. It is concise and readable, though it is too terse to compensate 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, a widespread 'discarded after check' pattern, no annotations, and no output schema, one sentence is insufficient. An agent cannot reliably determine which parameter to pass or what response format to expect.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning beyond the word 'place', and some schema descriptions are confusing, but the schema does document every parameter.

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

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

The description states a specific resource and output: latitude and longitude for a place via Open-Meteo. It is clear enough to convey that this is a geocoding-style lookup, though it does not explicitly name the input field or differentiate itself from sibling hint tools.

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

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

There is no when-to-use guidance or comparison to alternatives such as weather-hint. The description also fails to indicate which of the nine optional schema parameters should be populated, so an agent must guess between city, query, and other fields.

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 describes the parse action but does not disclose whether the tool makes network calls, how invalid GitHub URLs are handled, what the return shape is, or that most of the nine input parameters are ignored/discarded.

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

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

The description is a single sentence with no wasted words. It is front-loaded with the action and the target resource, making it easy for an agent to quickly grasp the tool's 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?

Given nine optional parameters, no annotations, and no output schema, a one-clause description is insufficient. The agent cannot tell which parameters are relevant, what the tool returns, or how it behaves on malformed URLs without additional investigation.

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 slight specificity by identifying the URL as a GitHub URL, but it does not clarify how the other eight parameters relate to this tool or why they are accepted.

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: 'Parse owner and repo from a GitHub URL.' It is specific enough to understand the tool's core purpose, but it does not explicitly contrast with sibling shape tools such as domain-shape, figma-url-shape, 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?

Usage is only implied: an agent can infer this tool is for extracting owner and repo from a GitHub URL. However, there is no explicit guidance about when to choose this over sibling tools like normalize-url or domain-shape, and no mention of 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?

The description carries the full burden because no annotations are provided. It does disclose that titles are discarded, which is a small behavioral hint, but it omits critical details: how the count is returned, whether a network request is made, whether parameters are ignored, and what happens on failure or rate limiting. This is insufficient for a tool with no annotation support.

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 with the core action. The second sentence, 'Titles discarded,' is terse but adds a behavioral note. It is not bloated, though the wording could be clearer; no words are wasted.

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, no output schema, and 9 optional parameters, the description is too incomplete. It does not specify the return format, whether any parameters are used, how to invoke it correctly, or what side effects or dependencies exist. An agent would be uncertain whether to pass the 'feed' parameter, the 'url' parameter, or nothing 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 tool description adds little beyond the schema, and it does not clarify which of the 9 optional parameters, if any, are relevant to counting Hacker News stories. The schema descriptions are present but the tool description does not help an agent map parameters to this tool's 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 states a specific action and resource: 'Count current Hacker News front-page stories.' This is clear, precise, and distinct from the sibling tools, which focus on URL checks, time zones, weather hints, and other unrelated operations. The verb 'count' and the bounded resource make the tool's purpose immediately obvious.

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 web-fetch, fetch-status, or other counting tools. The description gives no context, exclusions, or conditions that would help an agent choose this tool over a sibling. Usage is only implied by the purpose statement.

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 the tool involves common IANA timezone names but does not disclose what the tool actually does (returns a list? validates a name?), whether it is read-only, what output format to expect, or why the schema contains nine unrelated parameters that are mostly 'discarded'.

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

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

The description is a short, front-loaded phrase with no redundant words. It efficiently communicates the core topic and intended use context, though it is more of a fragment than a complete 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?

Given nine parameters, no output schema, and no annotations, the description is severely underspecified. It doesn't state the return shape, whether the parameters are ignored or used for validation, or how the tool behaves at all. The surprising mismatch between the timezone-focused description and the unrelated parameter list further reduces an agent's ability to invoke it confidently.

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

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

Schema description coverage is 100%, so each parameter is individually documented with its own meaning, meeting the baseline. However, the tool description itself adds no parameter-level guidance and does not explain how these unrelated parameters (git ref, URL, city, etc.) relate to IANA timezone names, leaving the connection ambiguous.

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

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

The description names the resource ('IANA timezone names') and a purpose ('for clock calls'), but it is a noun phrase without a verb like 'lists' or 'returns'. It partially restates the tool name and does not clearly differentiate from sibling tools like 'timezone' or 'utc-time' beyond a vague purpose context.

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 is useful when working with clocks or time, but it gives no explicit when-to-use or when-not-to-use guidance. It does not mention alternatives, any prerequisites, or conditions that would make this tool the correct choice versus sibling tools.

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

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

No annotations are provided, so the description carries the full transparency burden. It reveals the read-only nature implicitly but does not disclose network access behavior, which parameter selects the target host, failure behavior, redirects, rate limits, or the fact that the many unrelated input parameters are ignored.

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

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

The description is a single front-loaded sentence with no filler. It is concise and readable, but it sacrifices essential usage details for brevity, so it does not quite reach the highest tier of helpfulness.

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, no output schema, and a generic shared schema, this one-sentence description is not enough for an agent to call the tool correctly. It never explains which parameter is needed, how group counts are returned, or what happens when unrelated parameters are passed.

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 parameter descriptions are generic and disconnected from the tool's purpose. None of them is explicitly tied to locating a robots.txt for a given site, and the tool description does not say whether 'url', 'host', or some other parameter is the required input. The description fails to add meaning beyond the generic schema.

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

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

The description states a specific verb ('Fetch'), a concrete resource ('public robots.txt'), and the precise output ('group counts only'). This clearly distinguishes it from generic fetching or status-check siblings like web-fetch, fetch-status, and 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 gives no guidance on when to use this tool versus alternatives such as web-fetch or fetch-status. It does not mention when not to use it or what condition should route an agent here instead of a sibling.

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

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

The description discloses that the key is discarded, which is a useful privacy note, but says nothing about what the tool returns on success or failure, how strict the shape check is, or any side effects. With no annotations, the description carries the full transparency burden and does not meet it.

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

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

The description is only two sentences, front-loaded with the core purpose, and contains no filler. It is concise, though it sacrifices essential information that would be needed for reliable invocation.

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

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

With nine parameters, no annotations, and no output schema, this two-sentence description is far from sufficient. The mismatch between the stated Jira-key purpose and the unrelated parameter set is a critical gap, and the tool cannot be reliably invoked from this definition alone.

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

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

Although every schema parameter has its own description, the core concept of a Jira key is not mapped to any of the nine parameters. The description adds no parameter-level guidance, and the schema contains no obvious 'key' property, leaving the correct invocation ambiguous.

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

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

The description clearly names the action and resource: checking the shape of a Jira issue key. It is distinguishable from sibling shape tools because it specifically targets Jira issue keys. However, it does not mention the return value or how the key relates to the schema parameters.

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 like domain-shape, figma-url-shape, or github-repo-shape. The description states only the core action, leaving the agent to infer the full usage 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?

The description discloses a real behavioral trait: it returns only the HTTP status and discards the body. However, with no annotations present, it does not cover expected network behavior such as redirects, timeouts, or error handling, and it never explains why nine unrelated optional parameters are accepted.

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 first states the core purpose and the second states the key behavioral constraint. Every word earns its place and the information is front-loaded.

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

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

With nine optional parameters and no output schema or annotations, this two-sentence description is insufficient. It does not say which parameter identifies the URL to check, what the returned status looks like, or what happens when multiple parameters are provided.

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

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

Schema description coverage is 100%, so the baseline applies; the schema already documents each parameter. The main description adds only the 'public library docs URL' framing, but does not map it to the `url` parameter, and the schema's `url` description ('normalize or cite') sits awkwardly with the HTTP-status 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 specific operation ('HTTP status') and a specific resource ('public library docs URL'), and the added note 'Body discarded' clarifies scope. It does not explicitly contrast with siblings such as fetch-status or browser-url-ok, so it stops short of full sibling differentiation.

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

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

There is no guidance about when to use this tool versus the many URL/status siblings (fetch-status, browser-url-ok, normalize-url). No alternative conditions or exclusions are provided, so the agent must infer fit from the name alone.

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

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

The phrase 'Values discarded' adds one behavioral detail, but with no annotations the description carries a heavier burden and does not disclose output type, invalid-JSON behavior, nested-object counting semantics, or any side effects. The parameter descriptions hint that many inputs are discarded, but the tool-level behavior remains vague.

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 core action is front-loaded, and 'Values discarded' is placed immediately after.

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

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

The tool has 9 parameters, no output schema, and no annotations, yet the description only gives a terse purpose without explaining which parameter provides the JSON, what the return value is, or how errors are handled. An agent would struggle to invoke this tool correctly without further inference.

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 each parameter already has a description. The tool description itself adds no parameter-level insight, especially failing to identify which parameter is the JSON object to count. Baseline 3 is appropriate because the schema bears the load, though the parameter descriptions are oddly mismatched with the stated counting 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 clear verb and resource: 'Count keys in a JSON object.' It distinguishes the core action from validation-type siblings like validate-json, though it does not explicitly name that sibling or clarify whether nested keys are included.

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 instead of alternatives such as validate-json or other counting/checking tools. The description gives no exclusivity conditions, prerequisites, or context for choosing 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 provided, so the description carries the full disclosure burden. It does add meaningful non-obvious behavior: query strings and fragments are stripped from the output. However, it stays silent on validation errors, behavior when url is omitted, and the fact that the tool accepts eight other parameters that the schema marks as discarded — the description never acknowledges the tool's broad parameter surface.

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

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

Two sentences with zero filler, and the primary action is front-loaded. Both sentences carry distinct information — what is returned and what is dropped — so 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 output schema and no annotations, the description is lean for a tool that has nine parameters. It explains the return concept (origin, host, path) but not the output format, failure modes, or how an agent should treat the other eight parameters beyond what the schema says. It is adequate for the common case but leaves meaningful gaps.

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

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

Schema description coverage is 100%, so the baseline is 3, and the schema handles most parameters well with explicit 'discarded' notes. The description adds genuine meaning for the url parameter by defining what 'normalize' produces (origin, host, path) and the drop-query/fragment behavior, which goes beyond the schema's vague 'normalize or cite' phrasing.

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 (Return), resource (URL), and exact output components (origin, host, path), making the tool's core function unambiguous. It implicitly distinguishes itself from siblings like browser-url-ok (a validity check) and domain-shape (domain shape only) by describing component extraction rather than validation, though it never names an alternative 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?

There is no when-to-use or when-not-to-use guidance, no prerequisites, and no mention of alternatives such as browser-url-ok, domain-shape, or web-fetch. The agent must infer that this tool is for extracting components from a URL, and the description offers no help in deciding between the many 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 provided, the description carries the full behavioral burden. It discloses one useful trait: no browser is launched. But it omits other important behaviors, such as side effects (read-only?), return format, error handling, and how the additional parameters (ref, city, json, path) are processed. This is minimal transparency, not misleading but insufficient.

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

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

The description is a single, tightly crafted sentence that front-loads the action and immediately adds a crucial behavioral distinction. No words are wasted, and the structure makes the core purpose instantly clear. It is appropriately sized for the high-level information it intends to convey.

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 a broad, diverse schema (url, path, json, city, ref, feed, host) and no output schema or annotations, yet the description only covers the URL-checking aspect. An agent cannot infer how to handle the other parameters, what the tool returns, or what 'opened' means operationally. This creates a significant completeness gap despite the schema's individual parameter notes.

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

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

The input schema provides descriptions for all eight parameters, including notes like 'discarded after the shape check' and 'titles discarded,' so schema coverage is high. The tool description adds no parameter-level meaning, defaulting to the baseline score of 3. It neither enhances nor conflicts with the schema's explanations.

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 ('Check') and resource ('whether a URL can be opened'), and the second clause 'No browser is launched' differentiates it from likely sibling browser-url-ok. However, 'can be opened' is imprecise about what exactly is checked (HTTP reachability, renderability, etc.), and the schema's non-URL parameters (json, city, path) are not reflected in the stated purpose.

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

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

No explicit guidance is given for when to use this tool versus alternatives. The only context clue is 'No browser is launched,' which weakly implies a lightweight check, but it does not name sibling tools (e.g., fetch-status, browser-url-ok) or state exclusions. An agent must infer usage from the name and one behavioral clause.

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

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

With no annotations provided, the description carries the full burden and does disclose one meaningful behavioral trait: the query is discarded. However, it does not clarify that the other eight schema fields appear irrelevant to the count, nor does it describe the return value, leaving some behavioral uncertainty.

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 behavior is front-loaded. 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?

The tool is simple and the schema documents every parameter, so extensive description is not required. Still, with no output schema and no explicit statement that only `query` is used, an agent might wonder whether parameters like `url`, `host`, or `zone` affect the 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 a baseline of 3 is appropriate. The description reinforces that `query` is the search text being counted, but it does not help an agent understand how to treat the many other optional parameters that look decoy-like.

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 action ('Count characters') and identifies the exact resource ('a search query'), while also noting the query is discarded. This clearly differentiates it from siblings like memory-key-count and hn-front-count, which count different things.

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, nor any mention of what makes it distinct from sibling count/shape tools. The agent must infer usage purely from the name and one-line 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 provided, the description carries the full burden of explaining behavioral traits. 'Short catalog' vaguely suggests a read-only reference, but it does not disclose whether parameters are accepted or ignored, what the output format is, or whether any side effects occur. The schema's parameter descriptions mention values being 'discarded,' which is important behavioral context absent from the description.

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 one short sentence, which is concise, but it is under-specified rather than appropriately sized. For a tool with nine parameters, no annotations, and no output schema, a one-sentence noun phrase does not serve as adequate structured guidance.

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

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

The tool has 9 parameters, no annotations, and no output schema, and the description gives almost no context about invocation, expected behavior, or return value. The description also fails to reconcile the apparent mismatch between 'HTTP status codes' and the unrelated parameter names like city, feed, json, and path. This is a severely incomplete definition for an agent to call 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 input schema already documents all nine parameters with meaningful details. The description adds no parameter-level meaning and does not connect the parameters to the catalog purpose. Baseline 3 is appropriate because the schema carries the parameter documentation 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, 'Short catalog of common HTTP status codes,' is essentially a noun phrase that restates the tool name 'status-catalog' without adding a specific verb or action. It does not say what the tool does with its inputs, and it does not distinguish itself from siblings like fetch-status 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?

There is no guidance on when to use this tool versus alternatives. The description implies it is a reference for HTTP status codes, but it does not mention any sibling tools, conditions, exclusions, or prerequisites. An agent would have to infer usage from the tool name rather than from 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 behavioral burden. 'Prompt discarded' is a useful disclosure that the input prompt does not influence the result, and returning a template implies a read-only operation. However, it omits details about whether the nine parameters are consumed, ignored, or required for the template, and it does not describe the output shape beyond 'three-step.'

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, both informative ('what it returns' and 'prompt handling'), with no filler or redundancy. It is appropriately brief, though the cryptic 'Prompt discarded' could be slightly 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?

For a tool that simply returns a template and has no required parameters, the description plus a fully-covered optional schema may be enough to call it. Still, the relationship between the prompt-discard note and the nine declared parameters is unexplained, and with no output schema an agent is left to infer what a 'three-step thinking template' actually contains.

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 input schema provides detailed meanings for ref, url, city, feed, host, json, and path. The tool description adds no parameter semantics, but with complete schema coverage the baseline of 3 is appropriate; there is no gap to compensate for.

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 result: 'Return a three-step thinking template.' This is a specific verb plus resource and sets it apart from sibling validation and URL-checking tools. The 'Prompt discarded' note is extra but does not explicitly distinguish it from alternatives.

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

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

There is no guidance on when to choose think-steps over sibling tools, no exclusions, and no context about the intended use case. An agent only learns what it returns, not when it should be invoked.

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 explaining behavior. It only says 'Current time' and does not disclose return format, behavior for invalid timezone names, network dependencies, or whether other schema parameters are ignored. The read-only nature is implied but not explicitly clarified.

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

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

The description is a single front-loaded sentence with no filler. It efficiently communicates 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?

Given 9 schema parameters, no required fields, and no output schema, the description is too thin. It does not clarify the return value, why unrelated parameters exist, or whether a timezone input is needed. An agent would need to rely on the schema and still might be unsure about expected output or edge cases.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds no parameter-level meaning beyond what the schema already provides; 'named IANA timezone' essentially restates the timezone 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 clearly states the action and resource: returning the current time for a named IANA timezone. It also distinguishes the tool from siblings like utc-time and iana-zones by specifying the IANA timezone 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 gives a clear context for use: when current time for a named IANA timezone is needed. It does not explicitly mention alternatives or exclusions, but the IANA-timezone qualifier makes the appropriate usage reasonably clear.

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

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

With no annotations present, the description carries the full burden, and 'Current UTC timestamp' adds little beyond the tool's name. It does not disclose the output format, precision, or that the many input schema parameters appear unrelated or 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 a single short sentence with no wasted words, making it efficient and front-loaded. It is, however, too terse to convey output format or parameter relevance, which slightly limits the value of its 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?

Although the tool itself sounds simple, the unrelated-looking seven-property schema and lack of return type details leave the description incomplete. Without annotations or output schema, an agent cannot confidently know whether parameters are optional or what the response will look 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?

The input schema provides detailed descriptions for all seven parameters, so schema coverage is high and the baseline is 3. The description adds no explanation of how these parameters relate to the UTC timestamp purpose, which may leave agents unsure whether any arguments are needed.

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 a specific resource and output. It does not, however, differentiate itself from sibling tools like 'timezone' or specify the timestamp format, so it stops short of a 5.

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

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

No guidance is given about when to use this tool versus alternatives such as 'timezone' or 'iana-zones'. The description provides no context, exclusions, or conditions for selecting this tool.

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. It does disclose that the body is discarded, but it does not explain what happens on invalid JSON, whether the check is local or network-based, or what response/error shape to expect. The discard note also largely repeats parameter descriptions 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?

Two short sentences with the purpose front-loaded and no filler. The discard note is concise, though it is already reflected in parameter 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?

The definition is too thin for a tool with 9 optional parameters, no annotations, and no output schema. It does not clarify which parameter is the 'body', why the other eight parameters exist, or what a successful/failed validation returns, leaving an agent to guess.

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. It also introduces the ambiguous term 'body' without mapping it to the 'json' property, though the schema itself clarifies 'JSON text to validate'.

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

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

The description states a clear action and target: 'Check whether a body is valid JSON'. This is specific enough to distinguish it from sibling shape/URL/path validators, though it does not explicitly name any sibling or the 'json' 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?

There is no guidance on when to use validate-json versus alternatives, what scenarios call for it, or which parameters are relevant. The description only states the action and discarding side effect.

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 not mention that most parameters are discarded, what the response format is, whether network access is required, or what happens on failure.

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

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

The description is a single, front-loaded sentence with no filler. It is concise, though it achieves that conciseness at the expense of important contextual information covered by 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?

The tool has nine optional parameters, no output schema, and no annotations, but the description only covers the core city-temperature purpose. An agent would not know how to handle the other parameters or what to expect in the response.

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 no additional parameter context beyond identifying city as the relevant argument for temperature.

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

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

The description clearly states the tool's function: retrieving current temperature for a city via Open-Meteo. It is specific enough to distinguish weather-hint from sibling tools like geo-hint, though it lacks an explicit verb and is phrased as a noun phrase.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor does it mention any exclusions or conditions. It implies a weather lookup use case but never states it directly.

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 behavioral burden. It does disclose the key behavior that the body is discarded and restricts usage to public URLs, but it omits details such as redirect handling, authentication expectations, response representation, and what happens to the other schema 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?

Two short sentences deliver the core purpose and the most important behavioral caveat with no filler. The key information is front-loaded and every word contributes.

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 sparse description for a tool with no output schema, no annotations, and a multi-field input schema. It adequately states the core behavior, but leaves gaps around return format, redirect behavior, and why several parameters are present yet described as 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?

The input schema provides descriptions for all eight parameters, so the schema already carries most parameter meaning. The description only adds the 'public URL' constraint and does not clarify which parameter is the primary input or reconcile the schema's 'normalize or cite' wording with the described fetch 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 clearly states the tool reports HTTP status and content type for a URL, and it adds the useful detail that the body is discarded. This distinguishes it from content-fetching tools, though it does not explicitly differentiate it from the sibling fetch-status tool.

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 'public URL' gives a scope, and 'body discarded' implies the tool is for lightweight header/status checks rather than content retrieval. However, it does not name alternatives or state explicit when-not-to-use conditions, despite several related sibling tools being available.

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

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

The description does disclose that the input title is discarded after the call, which suggests a stateless, non-persistent check. However, with no annotations, it does not disclose return behavior, error behavior, network usage, or whether this is a live Wikipedia lookup.

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

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

The description is short and front-loaded, stating the key purpose in the first sentence. The second sentence adds a statelessness hint, though it is somewhat ambiguous given the missing title 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?

The tool is not complete enough to invoke correctly: the main input parameter is absent from the schema, there are no annotations, no output schema, and no explanation of results or edge cases. The description alone leaves critical gaps.

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

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

The description mentions a 'title' but the input schema has no title parameter; instead it lists unrelated fields like ref, url, city, feed, host, json, and path. No schema description or tool description explains which parameter carries the Wikipedia title, making the tool effectively uncallable from the provided documentation.

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

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

The description states a specific verb and resource: 'Check whether a Wikipedia title exists.' This clearly distinguishes it from sibling tools like validate-json or normalize-url, even though it doesn't name 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?

There is no guidance on when to use this tool versus alternatives such as web-fetch or fetch-status. The only implied usage is checking Wikipedia title existence, but no context, prerequisites, or exclusions are provided.

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