Currency NZD

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

With no annotations, the description carries the disclosure burden. It states what the tool returns and explicitly discloses that task text is discarded, which is a useful privacy and side-effect signal. It doesn't cover auth, rate limits, or whether the returned remote MCP hops involve additional executions, but the core lookup behavior is 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 compact and front-loaded: purpose, returned artifacts, then a discard warning. Every sentence adds distinct information and there is no filler.

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

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

For a tool with no output schema, it helpfully enumerates the returned artifacts and warns about discarded text. However, the 9 optional parameters are not connected to the Monid lookup, and the description does not clarify whether arguments are needed or ignored, leaving some ambiguity 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 has 100% description coverage across all 9 parameters, so the structured schema already carries the parameter-level meaning. The tool description adds no param-specific guidance beyond noting that task text is discarded; with no required parameters, an agent can rely on the 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 resource ('public pay-per-call tool gateway (Monid)') and lists the exact outputs (CLI setup, how-it-works, skill file, remote MCP hops). It distinguishes itself from sibling tools by targeting Monid, which none of the siblings mention, though it doesn't explicitly connect to the 'agent-tool-index' name.

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

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

The intended use is implied: call this when the agent needs Monid or pay-per-call gateway setup. 'Task text discarded' also signals it is not for general task processing, but there are no explicit when-to-use or when-not-to-use conditions, nor named alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals one useful trait ('No browser is launched'), but it says nothing about whether a network request is made, whether the operation is side-effect-free, how errors are surfaced, or what the result means. This is minimal disclosure.

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 with no filler and is front-loaded around the main purpose. It is not bloated, but it is so terse that it under-specifies important operational context, so it is not a perfect conciseness score.

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, heterogeneous parameters and no output schema, yet the description provides almost no contextual information. An agent cannot determine what 'ok' means, what the return value looks like, which parameters are relevant, or how the discarded parameters relate to the operation. This is far from complete.

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 because the schema already documents all nine parameters. The tool description adds no parameter-level meaning beyond the schema; it only references the URL concept broadly.

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

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

The description states a clear action ('Check whether a URL can be opened') and adds a distinguishing behavior ('No browser is launched'), which separates it from browser-launching siblings like playwright-url-ok. However, it does not specify what 'can be opened' means operationally (e.g., HTTP status, DNS resolution, content-type check), so the purpose is clear but slightly imprecise.

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

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

There is no explicit guidance about when to use this tool versus alternatives such as web-fetch, fetch-status, normalize-url, or playwright-url-ok. 'No browser is launched' hints at a lightweight check, but no condition, exclusion, or alternative is named, leaving the agent to infer 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?

Annotations are absent, so the description carries the full burden of behavioral disclosure. It does mention that the expression is discarded, but it fails to clarify return behavior, side effects, required inputs, or auth considerations. The discard note is also attached to an 'expression' that does not appear in the schema, weakening its usefulness.

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 main action. The second sentence is somewhat unclear, but the length and structure are appropriately efficient.

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, no annotations, and no output schema, the description is drastically insufficient. It does not state which parameter to pass, what the tool returns, whether inputs are validated or transformed, or how the arithmetic behavior relates to any of the schema fields.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds no parameter meaning and introduces an 'expression' concept that is not one of the nine schema properties. This can mislead parameter selection instead of helping it.

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 action ('Evaluate a+b style arithmetic'), which is more than a tautology, but it is vague because no schema parameter corresponds to an expression. It also provides no differentiation from the many sibling validator tools, so an agent cannot tell exactly what this tool is for in 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?

No usage guidance is provided: there are no when-to-use conditions, exclusions, or alternatives. The only implied use case is arithmetic evaluation, but the input schema does not support that, and nothing distinguishes calc-eval from siblings like validate-json, normalize-url, or 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 transparency burden. It discloses that page content is not stored, but it does not mention network access, side effects, lack of persistence for other inputs, or whether any mutation occurs. Most parameter behaviors are left to the schema descriptions, not the tool 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 concise and front-loaded with the primary action and result. Two sentences are easy to scan, and the safety note is placed after the core purpose, which is a reasonable 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?

Given nine optional parameters and no output schema, the description is not complete enough for an agent to invoke the tool correctly. It does not explain which parameters are mutually exclusive, how the output is structured, what happens when multiple parameters are supplied, or why the tool is named 'citation'.

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

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

Although the schema covers all parameters with descriptions, the tool description does not integrate them. The parameters span git refs, weather hints, feeds, JSON, timezones, and search text, but the description only explains URL-related output. The generic 'discarded after the shape check' phrasing does not clarify how each parameter relates to the tool's 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 opening phrase 'Return host, scheme, and HTTP status for a URL' identifies a concrete action and resource, but the tool name 'citation' and the nine heterogeneous parameters (ref, city, feed, json, zone, etc.) make the overall purpose ambiguous. It does not clearly distinguish this from sibling tools like fetch-status or normalize-url.

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

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

The description offers no explicit guidance on when to choose this tool over alternatives. The single sentence 'Page content is not stored' hints that it is a lightweight URL check rather than a content fetcher, but it does not name alternatives or specify conditions.

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

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

With no annotations, the description carries full responsibility for disclosing side effects and behavior. It does provide one meaningful guarantee: "No identifiers are retained." However, it does not say whether the tool performs network access, mutates state, returns a classification label, or what happens when multiple parameters are supplied together.

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 free of filler, and the privacy note is front-loaded. However, the brevity comes at the cost of essential content: there is no description of the classification output, categories, or invocation context. It is concise but not appropriately informative.

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

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

This tool accepts nine diverse optional parameters, has no output schema, and has no annotations, so the description must explain what the classification means and what the agent should expect. It does neither. The agent is left with no idea what "classified" refers to, what values will be returned, or how to interpret 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?

The input schema already documents all nine parameters with individual descriptions, so schema coverage is 100%. The tool description itself adds no parameter-level meaning, but the baseline of 3 applies because the schema carries the 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 says the tool "shows how this request is classified," which names an action and object, but the classification scheme and output are never defined. It does not distinguish this tool from the many siblings such as domain-shape, validate-json, or search-query-len. The purpose is understandable in the abstract but too vague to act on confidently.

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 call this tool versus any sibling tool. There is no mention of appropriate input selection, prerequisites, or cases where a different tool should be preferred. The only hint is the privacy statement, which is not enough to guide selection.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure. It only adds one negative behavioral fact (no WHOIS/ownership data) and implies no external enrichment, but it does not mention what output the tool produces, whether it is side-effect free, or how it treats the other 8 input parameters. It also fails to reconcile the hostname-only behavior with the entire parameter set.

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 sentence with no wasted words and places the main action first. It is under-specified for the tool's actual breadth, but conciseness itself is strong for the hostname-focused interpretation.

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 complex 9-parameter tool with no output schema and no annotations, a one-sentence description about hostname splitting is far from complete. It does not explain the intended use of these other fields, what the tool returns, or how the shape check works, leaving a roughly adequate agent to guess which input to provide.

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 covers all 9 parameters with descriptions (100% coverage), so the description does not need to repeat them. However, the general description provides no additional meaning about how parameters relate or which ones are intended for the hostname operation; it only mildly implies 'host' is the main one. This is exactly the baseline 3 situation where the schema does the heavy lifting.

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 ('split a hostname') and a scope ('without WHOIS or ownership data'), which gives some indication of the tool's core function. However, it does not align with the input schema's 9 optional parameters covering URLs, cities, feeds, JSON, paths, zones, and queries, so it reads as a narrow hostname tool while the schema implies a broader shape-checking utility. It only implicitly distinguishes from siblings like github-repo-shape by the word 'hostname'.

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 any of its 25 siblings, nor any mention of when not to use it. The single line does not name alternatives or give decision criteria.

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

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

No annotations are provided, so the description carries the full burden. It fails to disclose that the tool makes an external network request (HEAD to a URL), which could have side effects like hitting third-party servers, consuming bandwidth, or being blocked. It also does not specify what 'status' means (e.g., HTTP status code, or something else).

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 brief (one sentence), but it omits critical details such as what 'status' refers to, how the URL is specified, and what the return format is. While brevity is good, the lack of essential information makes it ineffective. There is no structure beyond a simple sentence, so it does not convey a clear mental model.

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 the description does not explain the return value beyond 'status only,' leaving the exact response format ambiguous. It also fails to contextualize the tool among its many sibling tools, making it impossible for an agent to determine when this tool is the right choice without additional probing.

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 for the parameters are entirely generic and do not align with the stated purpose of checking a URL. For example, 'ref' is described as 'Git ref name; discarded after the shape check' and 'city' as 'City name for a public weather hint; discarded after the call' – none of these relate to a URL. A real URL parameter is absent, so the descriptions add no meaningful guidance and actively contradict the tool's described purpose.

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

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

The description states a specific action ('HEAD a public URL and return status only'), but the purpose is muddied by the presence of nine parameters that are completely unrelated to URLs (e.g., 'ref', 'city', 'feed', 'zone', 'query'). This suggests the description may be mismatched with the actual tool parameters, so the intended purpose is not clearly conveyed.

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 indication of when to use this tool versus alternatives like browser-url-ok, playwright-url-ok, web-fetch, or normalize-url. It does not mention any prerequisites, limitations, or context in which it should be chosen over 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 full behavioral disclosure burden. It only adds 'Path discarded,' which is a minimal and ambiguous behavioral trait. It does not disclose what the tool returns, whether it validates URL format, whether it makes network calls, or what happens to the parsed data.

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

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

The description is extremely concise and front-loaded, with no filler words. 'Parse a Figma file URL. Path discarded.' is efficient but perhaps too terse for the operational complexity implied by the 9-parameter schema and absent annotations.

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, 9 optional parameters, and many sibling tools, this description is far from complete. It leaves critical unknowns: what the tool returns, what constitutes a valid Figma URL, whether 'path' refers to the URL path or the input parameter, and how to distinguish this tool from normalize-url or browser-url-ok. This is only a minimal stub.

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

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

Schema description coverage is 100%, so the baseline is 3. The description implies the 'url' parameter is the intended input by mentioning 'Figma file URL,' but it never explicitly says which parameter to use. The schema's 'url' description says 'HTTPS URL to normalize or cite,' which is not Figma-specific, and the other eight optional parameters add noise rather than useful guidance.

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.' This clearly distinguishes it from generic URL tools like normalize-url or browser-url-ok. However, it does not say what the parse produces, and the phrase 'Path discarded' is ambiguous about whether it refers to the URL path or the path 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 usage guidance is provided. The description does not mention when to prefer this tool over alternatives or when it should not be used, despite many sibling tools with overlapping URL-related purposes. The agent is left to infer usage from the tool 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, the description carries the full burden of behavioral disclosure. It usefully states 'No disk access,' but it does not disclose whether the tool is fully side-effect-free, what it returns, or how it behaves on invalid input.

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

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

The description is short and front-loaded, with no wasted words. It loses a point only because the key term 'safe' is left undefined, which brevity alone cannot excuse.

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

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

Given nine optional parameters, no output schema, and no annotations, the description is too thin for confident tool selection and invocation. It lacks return type, safety criteria, and sibling differentiation, leaving significant gaps for the agent.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds little beyond naming the path focus and does not explain why the schema exposes nine optional, seemingly unrelated fields or which one the agent should 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 names a specific verb and resource: 'Check whether a path looks safe.' The phrase 'No disk access' helps distinguish it from filesystem-touching tools. However, 'looks safe' is not defined, so the exact scope of the check remains 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 explicit guidance about when to use this tool versus sibling tools such as browser-url-ok, normalize-url, or fetch-status. 'No disk access' hints that it is a safe check, but no clear use conditions or exclusions are stated.

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

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

With no annotations, the description carries the transparency burden. It discloses that Open-Meteo is involved and that many parameters are 'discarded,' but it does not explain network side effects, error behavior, or whether the operation is strictly read-only beyond the obvious lookup nature.

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

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

The description is a single concise sentence and the schema is cleanly formatted with per-parameter descriptions. It loses a point because the parameter list adds noise without clarifying which fields actually matter.

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 cannot be confidently invoked from the definition alone: there is no output schema, no required field, and no explicit mapping from 'a place' to a schema parameter, so an agent would have to guess the input contract.

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

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

Although every schema parameter has a description, none clearly identifies the place input needed for latitude/longitude. Many descriptions say the value is 'discarded' or tie it to unrelated purposes, leaving the agent to guess between city, query, zone, or another 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 states a specific outcome ('latitude and longitude for a place') and names the method ('via Open-Meteo'). It is clear what the tool does, though it does not explicitly distinguish it from sibling tools like weather-hint.

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

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

The description gives only a general sense of usage. It does not say which parameter contains the place, when to prefer this tool, or how it differs from weather-hint, timezone, or other possible alternatives.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It does not mention that unrelated schema fields are ignored, whether any network or disk access occurs, or what happens for invalid GitHub URLs.

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

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

The description is a single, front-loaded sentence with no redundant words. It efficiently conveys 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 a nine-parameter schema with many irrelevant fields and no output schema, the one-sentence description is insufficient for an agent to know which fields to populate and what result to expect. It lacks guidance about return shape or error behavior.

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

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

The schema covers 100% of parameters, but most parameters (city, feed, json, path, zone, query) are unrelated to parsing a GitHub URL despite having plausible descriptions. The main description does not identify `url` as the key input or explain the role of the other optional fields.

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

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

The description 'Parse owner and repo from a GitHub URL' states a specific verb, object, and input source. It clearly distinguishes this tool from sibling URL/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?

The description implies usage when owner/repo extraction from a GitHub URL is needed. However, it does not explicitly state when to prefer this tool over alternatives such as normalize-url or jira-key-shape, nor does it provide exclusion conditions.

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

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

No annotations are provided, so the description carries the transparency burden. It reveals that titles are discarded, but it does not mention live network access, side effects, errors, or that most input parameters are ignored beyond per-parameter schema notes.

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

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

Two short sentences, front-loaded with the core purpose. No filler or redundant wording.

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 adequate for a trivial count-only action, but it omits output type, failure behavior, and any context about what 'current' means or how parameters like feed/url relate to the count. With no annotations or output schema, this is under-specified.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds no further relationship between the nine optional parameters and the HN front-page count; several parameter descriptions say they are discarded, but the overview does not clarify which, if any, affect the 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?

States a specific action and resource: counts current Hacker News front-page stories. 'Titles discarded' clarifies the result is only a count, not a list of titles.

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?

Does not mention when to prefer this tool over siblings such as web-fetch or fetch-status, nor when not to use it. The purpose implies counts are desired, but no explicit alternative guidance is 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 disclose behavior on its own, but it only states a noun phrase. It does not mention return values, side effects, ignored parameters, or any post-call behavior, despite several parameter descriptions referencing values being '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 single sentence is concise, but it is under-specified rather than tightly structured. It provides no action, no key qualifier beyond 'common,' and no front-loaded operational detail.

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

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

A 9-parameter tool with no output schema and no annotations needs a much richer description. The description leaves the return type, accepted input semantics, and relationship to the parameters completely unspecified.

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 has its own description and the baseline is 3. The tool description adds no parameter-level meaning, but the schema's parameter descriptions are present and moderately informative, even though they seem unrelated to IANA timezone names.

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

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

Names a concrete resource ('Common IANA timezone names') and the intended domain ('clock calls'), so an agent can infer the tool returns a timezone list. However, it lacks a verb/action such as retrieves or lists, and does not distinguish itself from siblings like timezone or utc-time.

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

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

No guidance on when to call this tool versus timezone, utc-time, or other siblings. The only hint is 'for clock calls,' which implies context but provides no exclusions or alternative routing.

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

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

With no annotations, the description carries the behavioral burden. It usefully discloses that the operation is a read-only public fetch and that output is deliberately limited to group counts. However, it does not address error behavior, redirects, whether the target is derived from host or url, or any rate/limit expectations.

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

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

A single, front-loaded sentence with no filler. Every word contributes either the operation, the target, or the output limitation.

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 9 optional parameters, no annotations, and no output schema, the description provides only one sentence. It does not say which parameters to supply, how unrelated parameters should be ignored, what a group count looks like, or what happens when the fetch fails. This is insufficient for reliable invocation.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds no parameter-level meaning. None of the parameter descriptions mention robots.txt, and the description does not clarify whether host, url, or path is the intended input, leaving the mapping to the agent to infer.

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 ('fetch'), a concrete resource ('a public robots.txt'), and an explicit output shape ('return group counts only'). This clearly distinguishes inspect-robots from siblings like web-fetch or fetch-status, which target general URLs or statuses.

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 text establishes a clear context: use this when the task is to fetch a public robots.txt and needs only group counts, not full content. It stops short of explicitly naming sibling alternatives or stating when to prefer web-fetch over this tool, so it misses the top score.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It does state that the input key is discarded, which is useful, but it says nothing about the result returned, whether external calls occur, or how valid and invalid keys 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 two sentences are tightly written and front-load the purpose with no filler. However, the definition is so terse that it omits necessary context; a sentence mapping the expected input or output would not be waste.

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 or annotations, and the input schema appears mismatched with the stated purpose. The description omits shape rules, return value, and routing guidance relative to the many sibling shape tools, so an agent cannot confidently invoke or interpret the tool.

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

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

The description names no parameter, and the schema exposes seven unrelated properties (url, city, feed, host, json, path) with no 'key' field. The only plausible candidate, 'ref', is described as a Git ref name rather than a Jira key, so an agent cannot reliably determine what to pass.

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

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

The description states a specific action ('Check') and resource ('a Jira issue key shape'), so the tool's core purpose is clear. It distinguishes itself from sibling shape tools by explicitly referencing Jira issue keys, though it does not describe the expected output or validation criteria.

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 siblings like github-repo-shape, domain-shape, or figma-url-shape. The phrase 'Key discarded' hints at a non-retaining behavior but gives no context for choosing this tool or exclusions.

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; it does reveal two useful behaviors: the result is an HTTP status and the response body is discarded. It does not mention redirects, timeouts, failure responses, or whether a network request is actually performed, but the core output and body-handling behavior are stated.

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

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

Two short sentences, front-loaded with the core operation and a useful qualifier about the body. It is concise without being padded, though it could have used the saved space for more 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?

There is no output schema, so the description should specify the return value format, but it only says 'HTTP status.' It also leaves unclear which of the nine optional parameters is relevant and what happens on network errors or invalid URLs, making the definition incomplete for a tool 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 is 3 even though the description adds no parameter details. The description's mention of URL implies the relevant field is `url`, but the schema also exposes eight other optional, unrelated-looking fields, so the description could have better disambiguated which parameter this tool expects.

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-resource pair: returns the HTTP status for a public library docs URL, and adds that the body is discarded. This is clear enough to distinguish it from general body-returning fetches, though it does not explicitly distinguish it from sibling status/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 choose this tool over the many URL/status siblings such as fetch-status, browser-url-ok, or normalize-url. The context of 'public library docs URL' implies a narrow scope, but there are no explicit when-to-use or when-not-to-use instructions.

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 only behavioral note is 'Values discarded,' which implies the input values are ignored. However, it does not disclose whether the tool is read-only, has side effects, what it returns, or any error conditions. With no annotations, this minimal statement is insufficient.

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

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

The description is extremely concise—two short sentences with no redundancy or filler. It front-loads the core action and a key behavioral aspect, achieving maximum efficiency for the limited information provided.

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 lacks essential context: no explanation of how to supply the JSON object, no expected output format, no mention of edge cases, and no relation to the sibling tools. Given the 9-parameter schema and no output schema, this is severely 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 tool description explains the function (count JSON keys) but does not indicate which of the nine parameters carries the JSON object. The schema's parameter descriptions (e.g., 'Git ref name,' 'City name for a public weather hint') are irrelevant to the stated purpose and do not add meaning. The agent cannot determine how to use any 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 'Count keys in a JSON object. Values discarded.' states the action (count) and the resource (JSON object), but it does not specify how the JSON object is passed (which parameter to use) or distinguish itself from sibling tools. The purpose is clear in isolation but ambiguous given the flat string 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 provided on when to use this tool versus alternatives. The description does not mention any specific conditions, use cases, or exclusions, leaving the agent without directional help.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It only mentions output processing (dropping query and fragment) but does not address potential side effects, network access, or error behavior. The lack of any side-effect information makes this dimension 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, direct sentence that front-loads the action and explicitly states the output constraints. There is no redundancy or filler, achieving maximal conciseness while maintaining clarity.

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

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

Given the tool has nine parameters and no output schema, the description is severely incomplete. It fails to explain the role of the majority of parameters, the expected output format, or how the URL normalization interacts with the provided fields. This leaves an agent unable to correctly invoke the tool.

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

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

The description does not explain any of the nine parameters. While the schema provides descriptions, they are unrelated to URL normalization (e.g., 'Git ref name', 'City name'), creating confusion. The tool description offers no clarification, so parameter semantics are effectively absent.

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 primary action: 'Return origin, host, and path for a URL' and specifies that query and fragment are dropped. This gives a specific verb, resource, and output scope, distinguishing it from other URL-related tools. However, the description does not reconcile with the extensive input schema, which introduces ambiguity about the tool's actual 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 usage conditions or alternative tool references are provided. The description does not indicate when to choose this tool over siblings like browser-url-ok or fetch-status, leaving the agent without guidance on appropriate invocation contexts.

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, but it only reveals that no browser is launched. It does not disclose whether a network request is made, whether the check is read-only, what side effects might occur, how return values look, or whether errors are thrown for invalid URLs. One behavioral fact is provided, but significant behavioral context is missing.

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

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

The description is extremely concise: two short sentences, no filler, and the core purpose is front-loaded. Every word contributes to the intended meaning.

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

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

This tool has 9 optional parameters, no annotations, and no output schema, yet the description only provides a one-line purpose and a single behavioral caveat. It does not explain what 'can be opened' means, what the tool returns, how URL checking relates to the other accepted parameters, or when to prefer it over sibling tools.

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

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

Schema description coverage is 100%, so the schema already documents all 9 parameters. The tool description adds no parameter-level meaning beyond the schema, which is acceptable under the baseline but adds no extra value here.

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 ('Check whether a URL can be opened') and a concrete resource (URL). The added phrase 'No browser is launched' offers a useful distinction from browser-centric alternatives, though it does not explicitly name a sibling tool or clarify how this differs from normalize-url or fetch-status.

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

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

There is no explicit guidance about when to use this tool versus alternatives like browser-url-ok, normalize-url, or web-fetch. The phrase 'No browser is launched' hints at a lightweight check, but the description never states conditions, exclusions, or preferred use cases.

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 burden of behavioral disclosure. 'Query discarded' usefully signals that the input is not persisted and that the operation is effectively stateless. However, it does not describe output format, error behavior, or whether non-query fields are ignored, leaving some behavioral ambiguity.

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

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

The description is two short sentences with no fluff: it states the core action first and then the key non-retention behavior. Every word earns its place, and the structure is front-loaded.

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

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

The tool has a generic nine-parameter schema with no required fields and no output schema, so the description could do more to clarify that only the `query` field is relevant and to state the return value explicitly. The existing text plus the schema's `query` description is likely enough for a simple length check, but it is not fully complete for an agent facing many optional parameters.

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

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

Schema description coverage is 100%, so the schema already documents each parameter, including `query` as 'Search text; discarded after the length check.' The description itself adds no parameter-level meaning beyond confirming that the query is discarded. Baseline 3 is appropriate because the schema carries the parameter documentation load.

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

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

The description clearly states the action ('Count characters') and the target ('a search query'), which distinguishes it from most sibling validators and counters. It does not explicitly name the `query` parameter or say the result is the character count, but the intent is recognizable from name + description.

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 instead of alternatives such as `memory-key-count`, `hn-front-count`, or the shape-checking siblings. The description implies its use for measuring search-query text, but it never states conditions, exclusions, or alternative 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 burden of disclosing behavior. It does not state whether the tool is read-only, what it returns, how inputs are used, or any side effects. The input schema is full of 'discarded after the call' fields, but the description does not explain this apparent behavior at all.

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

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

The description is short, but it is under-specified rather than appropriately concise. A single sentence that restates the name and adds minimal qualifiers does not earn its place; it fails to provide essential operational context while using up the entire description budget.

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 7 parameters with no output schema and no annotations. The description is only a fragment that does not explain how the parameters relate to a 'catalog of HTTP status codes,' what the expected output format is, or which sibling tools this overlaps with. An agent cannot correctly select or invoke this tool based on the current description.

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 7 parameters, so schema coverage is high. The description itself adds no parameter information, but because the schema already documents each parameter's meaning and disposition, a baseline score of 3 is appropriate. The description does not compensate for the mismatch between the tool's stated purpose and the heterogeneous parameter list, but it does not actively mislead 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 is a noun phrase that essentially restates the tool name: 'status-catalog' becomes 'catalog of common HTTP status codes.' It adds the qualifier 'HTTP' but provides no verb or action, so the agent cannot tell whether the tool lists, looks up, validates, or maps status codes. It does not meaningfully distinguish this from siblings like fetch-status or web-fetch.

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

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

There is no guidance about when to use this tool versus alternatives. The description gives no context, no examples, and no exclusions or preconditions. An agent has no basis to decide between status-catalog and other sibling tools.

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

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

Annotations already supply Active, Idempotent, and ReadOnly flags, so the description only needs to add behavior beyond those. It adds one meaningful behavior: the prompt is discarded. However, it does not clarify the output format or whether the tool has side effects, which is notable because annotations mark ReadOnly as false and Idempotent as false.

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 wasted words and the main deliverable is front-loaded. It is concise rather than minimal to the point of tautology, though the second sentence is a fragment 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?

For a tool with eight optional parameters and no output schema, the description is incomplete. It does not explain what the three-step template looks like, which parameters should be supplied, or what the agent should expect in the return value. The rich schema descriptions do not make up for this lack of overall context.

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

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

The input schema describes all 8 parameters in detail, so schema coverage is high and the baseline is 3. The description's only contribution to parameter semantics is 'Prompt discarded,' which usefully clarifies that the prompt parameter is not used, but it adds no meaning for the other seven parameters.

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

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

The description states a specific action and deliverable: 'Return a three-step thinking template.' It is not a tautology and the tool name matches. However, it does not define what the three steps are or differentiate this from sibling tools, so it is clear but not fully self-contained.

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

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

No guidance is given about when to call this tool versus any of the sibling tools. 'Prompt discarded' is a behavioral warning, not a usage policy or explicit selection condition. An agent has no information about prerequisites, expected inputs, or when not to use it.

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

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

No annotations are present, so the description carries the full behavioral burden. 'Current time in a named IANA timezone' suggests a read-only lookup, but it does not disclose the return format, DST behavior, invalid-timezone handling, or which of the many inputs are actually relevant.

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. Every word contributes to 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 with a fully documented input schema, the description is minimally adequate. However, with no annotations and no output schema, it does not clarify which parameter to pass or what the returned time value 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 coverage is 100%, so the baseline is 3 even though the description adds no parameter details. The phrase 'named IANA timezone' hints at the likely 'zone' parameter, but it does not add format or selection guidance 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 identifies the resource ('current time') and scope ('named IANA timezone'), so an agent can understand what the tool does. It does not explicitly compare itself to siblings like utc-time or iana-zones, but the IANA qualifier gives a natural differentiator.

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

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

The intended use case is implied: call this when the agent needs the current time for a named IANA timezone. However, there is no explicit when-to-use or when-not-to-use guidance, and no alternative tools 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, the description itself states the core behavior: a read-only retrieval of the current UTC timestamp. It does not disclose whether parameters are ignored or describe the timestamp format, but the input schema already labels most parameters as discarded/no-op, reducing the need for repetition.

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 clause with no filler, front-loading the essential information immediately. It is an appropriate size for such a simple tool.

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

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

The description is adequate for deciding that this tool returns a UTC timestamp and that no required arguments exist. However, it omits the timestamp format and does not clarify that the many optional parameters are decoys, so an agent is left with some ambiguity in a 9-parameter context.

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

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

Schema coverage is 100%, with each of the 9 optional parameters having a description, so the schema carries the parameter documentation. The description adds nothing about parameters, which is acceptable under the high-coverage baseline.

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 exactly what the tool returns: the current UTC timestamp. It is not tautological because it adds 'current' and specifies the resource, but it does not explicitly distinguish this from sibling time-related tools such as timezone or iana-zones.

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

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

There is no guidance about when to use this tool versus alternatives like timezone or web-fetch. No conditions, exclusions, or fallbacks are mentioned, so an agent must infer 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?

Annotations are null, so the description carries the full burden of behavioral disclosure. It only reveals that the body is discarded, offering a small hint about non-persistence, but it does not disclose what the tool returns, whether any URL/host/path parameters trigger network activity, or whether the operation is side-effect free.

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

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

The description is short, front-loaded with the core purpose, and has no filler. The discard note earns its place as a behavioral caveat, though the wording could have been slightly improved by explicitly referencing the `json` 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?

Given seven parameters, null annotations, and no output schema, the description is not complete enough. An agent cannot confidently determine which parameter is the 'body', what the validation result looks like, or whether the unrelated-looking URL/host/feed/path parameters are actually relevant.

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

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

All seven parameters have descriptive schema text, so schema coverage is high and the baseline applies. The description itself adds no parameter-level meaning and instead introduces the unclear term 'body' rather than pointing to the `json` parameter, but the schema compensates for that gap.

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

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

The description states a clear action: check whether something called a 'body' is valid JSON. This distinguishes it from the sibling validator tools by focusing on JSON, and it is not a tautology. However, the term 'body' is ambiguous because the input schema uses `json` as the actual parameter name.

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

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

There is no guidance on when to use this tool versus alternatives, nor any mention of prerequisites or postconditions. The only usage signal is the generic 'check whether' phrasing, which is not enough for an agent to decide when to invoke it instead of another validator or fetch 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, the description carries the full behavioral burden. It conveys a read-only temperature lookup via an external service, but it does not mention output units, error behavior, network dependency, or the fact that most schema parameters are ignored. The core behavior is adequately stated, but richer transparency is missing.

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

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

The description is a single front-loaded sentence with no filler, which is strong for conciseness. However, it may be somewhat too terse given the complexity of the nine-parameter schema and the absence of output schema or annotations.

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 does not specify which parameter to use, what the return format is, or that most schema fields are irrelevant. A correct invocation relies heavily on the agent inferring that only city matters, which is a significant completeness gap.

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 aligns with the city parameter and the schema already documents each parameter, but the description itself adds little semantic detail beyond naming the city input. It does not clarify which of the nine optional parameters 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?

The description clearly identifies the tool as returning current temperature for a city and names Open-Meteo as the data source. It is specific enough to match the weather-hint name and distinguish it from sibling hint tools like geo-hint, though it lacks an explicit verb such as 'returns' or 'gets'.

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

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

The description implies the tool should be used when a user wants a city's current temperature, so basic usage context is present. However, it provides no explicit when-not-to-use guidance, no mention of alternatives, and no indication that city is the only relevant parameter among the nine optional inputs.

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 and does disclose an important side effect: the response body is discarded. It also constrains targets to public URLs, but does not mention redirects, timeouts, authentication, or other request behavior that an agent might need to predict.

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 carry the essential information with no filler. The return scope and the body-discard behavior are front and center, making this appropriately concise.

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

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

The schema exposes nine optional parameters and no output schema, yet the description only addresses a URL fetch. It does not clarify how the other parameters relate to the tool, which fields are mutually exclusive, or what the response structure looks like beyond status/content type.

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 every parameter already has a semantic description in the schema. The tool description adds only the 'public URL' framing and does not explain the many non-URL parameters, so it meets the baseline but provides no extra meaning.

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

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

The description clearly states the tool's purpose: return HTTP status and content type for a public URL, and it explicitly notes the body is discarded. It is specific enough to identify the operation, but it does not differentiate this from siblings like fetch-status or browser-url-ok.

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

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

The phrase 'for a public URL' implies when the tool is appropriate and excludes non-public/internal targets. However, there is no explicit guidance about when to prefer this tool over siblings such as fetch-status, normalize-url, or browser-url-ok.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. The only behavioral detail is 'Title discarded after the call,' but there is no title parameter; nothing explains what 'exists' means, what the return value is, whether the call is read-only, or what happens with the other seven 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, but compactness is achieved by omitting critical information. The sentence 'Title discarded after the call' is confusing because no title input exists, and the description lacks the structure needed to make seven schema parameters understandable.

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, no annotations, and no guidance on which of the seven parameters to supply or how to interpret the result. For a tool that ostensibly checks existence, the definition is materially incomplete and would not allow a model to invoke it reliably.

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

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

The input schema does provide descriptions for all seven parameters, which gives it a baseline level of semantic coverage. However, the tool description refers to a 'title' that is not among the parameters, and the listed params (ref, url, city, feed, host, json, path) appear unrelated to checking a Wikipedia title, leaving the agent without a clear parameter to populate.

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

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

The description states an action ('Check') and an object ('Wikipedia title exists'), so it is not a pure tautology. However, the input schema exposes no title parameter, making the stated purpose unmappable to any callable input, and the description does not distinguish this tool from sibling validators like browser-url-ok or validate-json.

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

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

No when-to-use guidance is provided, and no alternative tools are named or excluded. The only additional sentence about 'Title discarded' does not help an agent decide between this tool and a sibling shape checker.

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