Asia/Thimphu clock

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

The description mentions 'Task text discarded' and some parameter descriptions note 'discarded after the call', but it does not disclose potential side effects such as external network calls, costs, or data handling. Since no annotations are provided, the description carries the full burden and 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 short, with only three sentences, and avoids irrelevant detail. It is front-loaded with the primary purpose, though the final sentence 'Task text discarded' is cryptic and could be clearer.

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

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

Given 9 optional parameters and no output schema, the description is not complete enough for an agent to know what to pass for a given task or what 'connection methods' means. There is no mapping between example tasks (weather, search, scrape, voice) and corresponding parameters, nor any detail about expected return values.

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

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

All 9 parameters have descriptions, but most are terse and focus on disposal or simple checks (e.g., 'discarded after the call', 'no disk access'). The descriptions add some context beyond raw names, but they do not explain how each parameter relates to the tool's purpose of finding a gateway.

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 ('Find a public pay-per-call tool gateway') and gives example task categories, but 'tool gateway' is vague and not tied to the tool's name or the concrete parameters. It does not explicitly distinguish this tool from sibling tools like weather-hint 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?

The description suggests tasks such as weather, search, scrape, or voice, but it gives no guidance on when to prefer this tool over sibling tools or when not to use it. There is no comparison, prerequisites, or selection criteria.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only mentions that no browser is launched, but it does not explain what 'opened' means (e.g., HTTP status check, reachability), what side effects might occur, why it accepts nine disparate parameters that are mostly discarded, or what the return format is. The description is too sparse to convey the tool's true behavior.

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

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

The description is extremely concise, consisting of two short sentences with no filler. It front-loads the core purpose and the key differentiator. There is no wasted text, so it earns a high score for conciseness, even though it sacrifices depth.

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, yet the description provides only a minimal statement of purpose. It fails to explain why the diverse parameters exist (e.g., city, zone, json) or how they relate to URL checking, nor does it describe the output or error behavior. For a tool of this apparent complexity, the description 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?

The input schema has 100% coverage, with each parameter individually described (e.g., 'discarded after the shape check'). The tool description adds no additional parameter information, so it does not go beyond the schema. Baseline of 3 is appropriate because the schema already documents the parameters adequately for invocation.

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

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

The description states a specific verb ('Check') and a clear resource ('whether a URL can be opened'), and it adds the key differentiator 'No browser is launched,' which distinguishes it from browser-based siblings like playwright-url-ok. However, it does not explicitly name the alternative, so the differentiation is implicit rather than explicit.

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

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

The description provides no guidance on when to use this tool versus its siblings. It only states what it does and the fact that no browser is launched, which hints at a choice but does not offer explicit conditions, alternatives, or exclusions. An agent would have to infer when this is 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 and a description that only says 'Expression discarded,' the tool's side effects, return value, error behavior, and actual operation are completely undisclosed. The description is actively confusing rather than 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 short and not verbose, but its brevity comes at the cost of essential information. It reads as a throwaway placeholder rather than a structured, useful tool description.

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

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

The tool has no output schema, no annotations, and a description that fails to explain its inputs, outputs, or relationship to the extensive sibling toolset. An agent would have no reliable basis for selecting or calling this 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?

All nine parameters have descriptions, but they are unrelated to arithmetic (e.g., 'Git ref name,' 'HTTPS URL,' 'City name') and several say they are 'discarded.' There is no parameter for the expression the tool supposedly evaluates, making the schema semantically incoherent.

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

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

The description says 'Evaluate a+b style arithmetic' but then immediately says 'Expression discarded,' which is contradictory and leaves the intended operation unclear. No input parameter is identified as the arithmetic expression, so an agent cannot tell what to pass or what the tool actually does.

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 sibling tool, no prerequisites, and no example of how to invoke it. The description provides no actionable usage information.

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

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

With no annotations, the description carries the burden of behavioral disclosure. The explicit 'Page content is not stored' is useful, but other details such as network behavior, permission needs, limitations, or error cases are 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 two sentences long, puts the main purpose first, and uses one extra sentence for a meaningful side-effect disclosure. No filler or repetition is present.

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 required fields, no annotations, and no output schema, yet the description only addresses 'a URL' without explaining which parameter to use, what to do with the non-URL parameters, or what happens with no input. Agent-facing ambiguity remains.

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 provides descriptions for all 9 parameters, so the baseline is met. However, the description adds no additional meaning about which parameter is primary or whether the many non-URL parameters should be used, discarded, or required.

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

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

The description opens with a clear verb and result: 'Return host, scheme, and HTTP status for a URL.' This makes the core operation obvious and separates it from unrelated siblings, though it does not explicitly contrast it with similar URL/status 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 usage guidance is provided. The description does not say when to choose this versus fetch-status, normalize-url, browser-url-ok, or other URL-related siblings, and it offers no exclusions or preferences.

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 states 'No identifiers are retained,' which is a useful privacy note, and some parameter descriptions mention 'discarded' or 'no disk access.' However, there are no annotations and no explanation of broader side effects, return behavior, or whether any network/file access occurs.

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 and parameter descriptions are compact and free of redundant text. The main description is a single short sentence, and each parameter is explained in one concise line.

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—nine optional parameters, no output schema, and no annotations—the description is not complete. It omits what the classification result looks like, how parameters are used together, and any prerequisites or limitations beyond scattered per-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?

All nine parameters have individual one-line descriptions, and several indicate discard/no-access behavior, but the descriptions are not tied to a coherent purpose. The relationships between parameters and the tool's classification behavior remain unexplained, so the meaning is only partially conveyed.

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 'Show how this request is classified' is too vague to indicate what the tool actually does or what resource it acts on. The name 'compatibility' and the nine unrelated parameters do not clarify the intended operation, and no sibling differentiation is provided.

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

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

The description gives no guidance on when to use this tool instead of any of the many sibling tools. There is no mention of alternatives, conditions, or decision criteria, leaving an agent unable to choose appropriately.

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 hints at a pure transformation by saying 'without WHOIS or ownership data', but does not explicitly disclose output, failure behavior, or side-effect-free 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?

Single, front-loaded sentence with 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?

For a tool with 9 optional parameters and no output schema or annotations, the description is too sparse: it does not say which parameter to use, what labels are returned, or how it relates to 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 coverage is 100%, but most parameter descriptions are generic or mismatched (ref, url, city, feed, json, path, zone, query) and marked discarded; only 'host' clearly relates to the stated purpose, so the description adds confusion rather than clarity.

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 verb 'Split' and resource 'hostname into labels', and explicitly scopes out WHOIS/ownership data, distinguishing it from related URL/fetch 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?

Implies use when only label splitting is needed and not WHOIS/ownership, but does not explicitly state when to prefer it over sibling tools like 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 provided, and the description does not address side effects, permissions, or rate limits. However, it does accurately state the safe HEAD behavior, offering basic transparency.

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, clear sentence with no unnecessary words, making it efficient and easy to parse.

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

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

The description fails to clarify how the 9 parameters relate to the tool, which is a significant gap given the schema complexity. It also omits details about the response format beyond 'status only', but the main missing context is the parameter semantics.

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 all 9 parameters have descriptions, these descriptions are clearly mismatched with the tool's purpose (e.g., 'Git ref name', 'City name for weather', 'IANA timezone'). They do not clarify which parameters are relevant and actively mislead the agent about the tool's functionality.

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 specifies the HTTP method (HEAD), the resource (public URL), and the output (status only), distinguishing it from sibling tools like web-fetch or browser-url-ok.

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

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

The description implies the use case—checking URL status without retrieving full content—but does not explicitly mention alternatives or when not to use it, 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 must carry behavioral transparency. It only says 'Path discarded,' which hints at a transformation but does not explain side effects, read-only status, output format, or error behavior.

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

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

The description is a single sentence with no filler or redundant information. However, it is so terse that it omits important context, so it is not maximally effective despite being 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 tool has 9 optional parameters and no output schema, yet the description does not explain what the tool returns, how to supply the URL, or what 'path discarded' means for the output. It is inadequate for an agent to use correctly.

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

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

Although schema description coverage is 100%, the parameter descriptions are generic and unrelated to Figma URL parsing (e.g., 'city', 'feed', 'query'). The tool description does not clarify which of the 9 optional parameters are relevant, making the schema misleading rather than helpful.

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 (Figma file URL) and the action (parse), and notes that the path is discarded. It is specific enough to distinguish from generic URL tools, though it does not state what the parse result looks like.

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

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

No guidance is provided about when to use this tool versus alternatives like normalize-url or browser-url-ok. There is no mention of conditions, exclusions, 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 provided, and the description gives no details about the return value, error behavior, or side effects beyond the explicit 'No disk access.' The agent cannot anticipate what the tool outputs.

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 consists of two short, direct sentences with no fluff. It is highly concise and easy to parse.

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

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

The description conveys the essential purpose but lacks any information about the output format (e.g., boolean, error messages) or behavior in edge cases. It is minimally sufficient for a simple check tool but not 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?

The only relevant parameter, 'path', is well described ('File path to check; no disk access'), but the schema inexplicably includes eight other unrelated parameters with plausible descriptions. This clutter undermines the clarity of which parameter is actually used and misleads the agent.

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

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

The description clearly states the tool's verb ('Check') and resource ('whether a path looks safe'), and distinguishes it from sibling 'ok' checks. However, the schema includes many irrelevant parameters (ref, city, feed, etc.) which adds ambiguity about the tool's actual scope.

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

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

The description does not specify when to use this tool versus alternatives (e.g., before reading a file, or when to prefer other 'shape' checks). The only guidance is 'No disk access,' which is a constraint, not 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?

With no annotations provided, the description carries full burden for behavioral disclosure. It does not mention whether the tool makes network calls, is read-only, can fail, or has side effects. 'Provides latitude/longitude via Open-Meteo' implies an external lookup but gives no detail.

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 fluff. It earns its place by stating the core function, though it is a noun phrase rather than a complete imperative 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 9 parameters, no output schema, and no annotations, the description is far from complete. It does not indicate which parameter is the place name, how results are returned, expected errors, or any operational context needed to call the tool correctly.

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

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

The tool description mentions no parameters, but the schema already documents all 9 with 100% coverage. Since schema coverage is high, the baseline of 3 applies; the description adds no extra meaning about how parameters relate to the geocoding 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 the tool's purpose: returning latitude and longitude for a place via Open-Meteo. It distinguishes geo-hint from weather-related siblings like weather-hint, though it lacks an explicit verb and does not mention which input parameter identifies the place.

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

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

No guidance is given on when to use this tool versus alternatives such as weather-hint or timezone-related tools. It does not state conditions for use, exclusions, or when another sibling would be more appropriate.

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

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

No annotations are present, and the description only states the high-level action. It does not disclose output format, invalid-input behavior, or whether the many extra parameters are ignored or affect the result.

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 main description is a single concise sentence. However, the input schema is bloated with nine irrelevant optional parameters, which undermines the overall structure and focus of the tool definition.

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 no description of the return value. For a parsing tool, the expected result shape (e.g., owner and repo as separate fields) is not specified, and failure modes are entirely absent.

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 unrelated to parsing GitHub owner/repo (e.g., city, feed, json, zone, query). With nine optional parameters and no meaningful explanations, the schema adds confusion rather than clarity.

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 verb and resource: parse owner and repo from a GitHub URL. It is distinguishable from sibling URL tools like normalize-url or figma-url-shape, though it does not clarify whether it validates the URL or only extracts components.

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

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

No guidance is given for when to use this tool over related URL or shape tools. There is no mention of required inputs, expected URL format, or how to handle non-GitHub URLs.

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 gives minimal insight into the tool's behavior. The phrase 'Titles discarded' hints at ignoring title data but does not disclose output format, side effects, or any other behavioral traits. With no annotations, the description carries the full burden, and it falls short.

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, using a single sentence to convey the core purpose. It is well-structured and avoids unnecessary verbosity, though its brevity contributes to the lack of substantive detail.

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

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

Given the tool's simple purpose but complex and seemingly irrelevant parameter list, the description omits essential context. It does not explain the relationship between the parameters and the tool, nor does it describe the expected output or return value, making the tool difficult to use correctly.

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

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

The description does not explain any of the nine parameters, and the schema descriptions are generic and seemingly unrelated to the tool's purpose (e.g., 'Git ref name', 'City name'). It is unclear how these parameters would be used or why they exist, leaving the agent without adequate guidance for invocation.

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') and the specific resource ('current Hacker News front-page stories'), making the tool's purpose unambiguous. It effectively differentiates itself from the sibling tools, which have distinct purposes like URL checking or calculation.

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

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

The description provides no information about when to use this tool versus alternatives. It does not mention any specific conditions, prerequisites, or scenarios where this tool would be preferred over other sibling tools.

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

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

No annotations are present, and the description gives no insight into side effects, return format, or operational behavior. The parameter descriptions mentioning 'discarded after the shape check' hint at some validation logic but do not clarify the tool's actual function.

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

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

The description is a single concise sentence with no unnecessary words. However, brevity comes at the cost of clarity, and the structure does little to convey the tool's function or scope.

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

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

With 9 optional parameters and no output schema, the description is far too incomplete for an agent to understand what inputs are meaningful, what results to expect, or how this tool differs from the timezone-related siblings.

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

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

Schema descriptions cover 100% of parameters, but they are inconsistent with the tool's stated purpose. Descriptions like 'Git ref name; discarded after the shape check' suggest unrelated validation behavior, and the tool description does not clarify how any parameter relates 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?

Description 'Common IANA timezone names for clock calls' is vague and lacks a clear verb. It doesn't explain whether the tool lists, validates, or transforms timezone names, and the wide-ranging parameters (url, city, json, etc.) do not align with this 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 guidance is provided on when to use this tool versus the many sibling tools (e.g., timezone, tz-asia-thimphu, utc-time). There is no mention of use cases, prerequisites, or alternatives.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it fails to mention that most parameters are ignored (as indicated in the schema, e.g., 'discarded after the shape check'). It also does not disclose network access, potential failures, or the meaning of 'group counts.' The description is vague about side effects and operational details, leaving the agent without critical behavioral context.

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

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

The description is a single, clear sentence with no unnecessary words, making it concise and front-loaded. It effectively communicates the core action and output, though it could be slightly longer to address other dimensions without losing efficiency.

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, many unrelated to the stated purpose, and no output schema, yet the description only provides a minimal summary of the return value ('group counts only'). It does not explain what 'group counts' means, how parameters affect the fetch, or what the full response structure looks like. For a tool with this complexity, the description is inadequate 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?

Schema coverage is 100%, so the baseline is 3. The description adds no information about parameters beyond what the schema already states, and several schema descriptions are misleading (e.g., 'city' is for a weather hint, unrelated to robots.txt). The tool description does not clarify which parameters are actually relevant to fetching robots.txt, so it fails to add value beyond 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 clearly states the action ('Fetch a public robots.txt') and the output ('return group counts only'), giving a specific verb and resource. However, it does not differentiate from sibling tools like 'web-fetch' or 'fetch-status', which also handle URL fetching, so it lacks sibling distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor any exclusions or context about the tool's specific niche. An agent would have to infer when 'inspect-robots' is appropriate from the name alone, which is not reliable given the many similar 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 burden of behavioral disclosure. It only states 'Key discarded,' which is cryptic and does not reveal whether the tool performs network calls, returns a boolean, or has any side effects. The behavior is essentially undisclosed.

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 (two short sentences), which is concise, but it is under-specified rather than efficiently scoped. The phrase 'Key discarded' is ambiguous and does not earn its place as a meaningful disclosure. It is short, but not appropriately structured for the tool'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 parameters, no required fields, no output schema, and no annotations, the description is grossly incomplete. It does not explain how to construct a valid call, what to pass, or what the tool returns. An agent has almost no information to use this tool correctly.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds no parameter-level meaning. More importantly, the parameter descriptions (e.g., 'Git ref name; discarded after the shape check') are generic and do not connect any parameter to a Jira key. The description fails to clarify which input is the Jira key, leaving the agent without a way to know how to invoke the tool correctly.

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 ('Check a Jira issue key shape'), which is not a tautology. However, it does not differentiate from sibling tools like figma-url-shape or github-repo-shape, and it does not indicate how the Jira key is derived from any of the nine input 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?

Provides no guidance on when to use this tool versus alternatives such as domain-shape or wiki-title-ok. There is no mention of conditions, exclusions, or context that would select this tool over its siblings.

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

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

The description only says the body is discarded, but does not disclose that most parameters appear to be ignored, validated, or discarded after unrelated checks. It also does not explain what the tool returns beyond 'HTTP status' or whether it has side effects.

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

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

The description is concise and front-loaded, but the phrasing 'public library docs URL' is confusing and the two sentences omit critical information about the tool's actual behavior.

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

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

With nine parameters and no output schema, the description is far too sparse. It does not explain return formats, error behavior, parameter combinations, or how the many unrelated inputs are handled.

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?

Each parameter has a short description, but these descriptions are inconsistent with the stated purpose (e.g., 'city' is for a weather hint, 'query' is for a length check). The descriptions do not clarify how or whether the parameters affect the HTTP status result.

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 claims to return an HTTP status for a 'public library docs URL', which is a specific action, but the input schema includes nine unrelated parameters (city, feed, json, path, zone, query) with no explanation of how they fit. The intended scope is unclear and likely misleading to an agent.

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

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

There is no guidance on when to use this tool versus sibling tools like fetch-status, browser-url-ok, or normalize-url. No conditions, alternatives, or exclusions 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?

'Values discarded' gives some transparency about not retaining input values, and there are no annotations. However, the description does not state what the tool returns, how nested keys are handled, or what happens on invalid JSON, so the behavioral disclosure is incomplete.

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

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

The description is concise and easy to parse, consisting of two short sentences. However, the overall structure is weakened by the large, unrelated input schema that is not reflected in the description.

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, the description is not enough for an agent to reliably use the tool. It does not explain which parameter to populate, what 'keys' means (e.g., top-level vs nested), or what output 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?

The schema has nine parameters, all optional, but their descriptions are unrelated to counting JSON keys. The only JSON-related parameter, 'json', says it is for validation and discarding after the check, which contradicts the tool's stated purpose of counting keys. No parameter clearly represents the JSON object to be counted.

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 resource ('Count keys in a JSON object') and adds that values are discarded. However, it does not map to any input parameter; the schema has a 'json' parameter whose description says 'validate' rather than 'count', so the actual purpose is unclear from the full tool definition.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that it should be used for counting JSON keys rather than validating JSON or other related operations, and no exclusions or context are provided.

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

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

With no annotations, the description carries the full transparency burden but only says query and fragment are dropped and origin/host/path are returned. It does not disclose side effects, error handling, or that most schema parameters appear to be 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 two short sentences, front-loads the main purpose, and contains no fluff or redundant boilerplate.

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 schema has nine optional parameters and no output schema, the description is severely incomplete; it does not explain the presence or purpose of the extra parameters, the exact 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?

Although every parameter has a schema description, most are irrelevant to a URL normalizer (e.g., city, ref, json, zone, query) and their descriptions like 'discarded after the shape check' are confusing. The only clearly relevant parameter is url, and its description adds 'or cite' which is unexplained.

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

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

The description uses a specific verb ('Return') and resource ('URL'), and clearly states the output components (origin, host, path) and that query/fragment are dropped. This distinguishes it from sibling URL tools like browser-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 guidance on when to choose this tool over alternatives such as browser-url-ok, web-fetch, or figma-url-shape. The description only states behavior, not selection criteria or exclusion 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?

The description discloses one negative behavior: no browser is launched. It does not state whether the tool makes a network request, what side effects or errors may occur, or what 'can be opened' means operationally. With no annotations provided, this is insufficient behavioral transparency.

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

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

The description is only two short sentences and places the main action first. It contains no redundant or filler content.

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

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

Given the large optional parameter set and no output schema, the description does not explain the return value, how to interpret the result, or why most parameters are accepted and discarded. The tool is too underspecified for reliable invocation in complex contexts.

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

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

Although every parameter has a schema description, many are described as 'discarded' after unrelated checks, and the main 'url' parameter is described as 'HTTPS URL to normalize or cite' rather than a URL to open. This mismatches the stated purpose and leaves the agent unsure which of the nine optional parameters are actually relevant.

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

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

The description names a specific verb and resource: checking whether a URL can be opened, and the second sentence adds a distinguishing constraint: no browser is launched. It is not fully precise about what 'can be opened' means (HTTP response vs. page render), but the core purpose is clear.

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

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

No guidance is given about when to prefer this tool over siblings such as browser-url-ok, fetch-status, or normalize-url. The only usage hint is negative ('No browser is launched'), with no scenario or criteria 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?

No annotations are provided, and the description only notes that the query is discarded. It does not disclose whether the tool performs validation, what side effects (if any) occur, or what the returned response contains.

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

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

The description is a single clear sentence with no fluff, making it easy to parse. It sacrifices some useful detail, but it is appropriately sized for a simple counting operation.

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

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

The description is too sparse for the actual schema: it does not explain why eight unrelated parameters exist, what the output format is, or how to choose among optional inputs. This leaves an agent uncertain about a 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?

Although the schema has descriptions, most are unrelated to the stated purpose (e.g., 'Git ref name', 'HTTPS URL to normalize or cite', 'City name for a public weather hint'). Only 'query' aligns with the tool's purpose, so the parameter meanings are misleading rather than helpful.

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 characters in a search query' uses a specific verb and resource, making the core action clear. However, the schema exposes many unrelated optional parameters (ref, url, city, feed, host, json, path, zone) that muddy which resource is actually being operated on.

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

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

There is no guidance on when to use this tool versus the many sibling validation/check tools. It does not state that it is for measuring query length only, nor does it mention any alternatives or preconditions.

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

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

No annotations are present, so the description carries the burden of disclosing behavior. It only says 'catalog,' which implies a read-only lookup, but it does not explicitly state side effects, whether inputs are ignored, or that no network/disk access occurs.

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, clear sentence with no unnecessary words or repetition. It is concise and well-structured.

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

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

Despite the short description, the tool has nine optional parameters that seem unrelated to a status-code catalog, and there is no output schema or explanation of how parameters affect results. This leaves the tool confusing and incomplete for a caller.

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 100% of parameters with descriptions, so the baseline is 3. The tool description itself adds no parameter meaning, but it also does not contradict the schema descriptions.

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

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

The description states the tool is a 'Short catalog of common HTTP status codes,' which conveys the general resource it provides. However, it lacks a clear verb like 'returns' or 'lists,' and it does not distinguish this from sibling tools such as 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 guidance on when to use this tool versus alternatives like fetch-status or web-fetch. The description does not mention any selection criteria, prerequisites, or intended 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?

Mentions that the prompt is discarded, which is a behavioral trait. However, it does not explicitly state that the operation is read-only or free of side effects, nor does it explain why the other parameters are discarded. Given no annotations, the description carries the burden but only partially fulfills 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 extremely concise, consisting of two short sentences. It is well-structured and immediately conveys the core functionality without unnecessary 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?

The description is adequate for a simple tool but lacks specification of the template's content or format. Since no output schema is provided, the user is left without details on what the 'three-step thinking template' actually looks like, which could be important for correct usage.

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

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

All 9 parameters have schema descriptions (100% coverage), but they are all marked as 'discarded' or similar, indicating they are ignored. The descriptions do not clarify why these parameters exist or how they relate to the tool's purpose. In fact, they are misleading because they imply the parameters are used while they are not.

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?

Clearly states the action ('Return') and the resource ('a three-step thinking template'). The phrase 'Prompt discarded' further clarifies that it does not process the prompt, making the purpose 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?

No guidance is provided on when to use this tool instead of the many sibling tools. The description does not differentiate it from alternatives or explain under what conditions it should be selected.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It only mentions the successful outcome and says nothing about side effects, error handling, read-only nature, or how the numerous extra parameters are treated.

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

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

The description is a single short sentence with no filler. It is concise and front-loaded, immediately stating the tool's 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 the tool has nine parameters and no output schema, a one-line description is far from complete. It does not explain the output format, required inputs, error behavior, or why the schema contains so many unrelated fields, leaving an agent without enough context to call it reliably.

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

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

Although every parameter has a schema description, most of those descriptions are irrelevant to a timezone tool (e.g., 'Git ref name', 'HTTPS URL to normalize', 'JSON text to validate') and appear copy-pasted. The tool description adds nothing beyond the one relevant parameter, 'zone', and fails to clarify which of the nine parameters actually matter.

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

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

The description clearly states that the tool returns the current time for a named IANA timezone. This is a specific verb+resource statement and distinguishes it from sibling tools like utc-time 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?

The description gives no guidance on when to use this tool versus alternatives, nor does it mention any required parameters, invocation pattern, or typical use case. It is a bare functional statement with no usage direction.

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

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

No annotations are provided, so the description carries the full burden. The description only states the purpose and implicitly suggests a read-only operation, but does not disclose any behavioral traits such as output format, error behavior, or rate limits. For a simple time tool this may be acceptable, but it adds no extra value beyond the basic statement.

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, which is concise and front-loaded with the purpose. However, it is too sparse given the complexity of the schema, and does not provide enough substance to justify 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?

With nine parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain what parameters to use, what the tool returns, or any edge cases. An agent would struggle to invoke this tool correctly 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 schema covers all parameters with descriptions, but the tool description adds no parameter-specific information. Moreover, the schema includes nine unrelated parameters (e.g., 'ref', 'url', 'city') that are not explained in the context of the tool's purpose, creating confusion about which parameters are relevant. The description does not clarify the role of the 'zone' parameter or any others.

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 provides the current local time for the specific timezone Asia/Thimphu. It uses a clear verb+resource, but does not differentiate from sibling tools like 'timezone' or 'utc-time' that might also provide time information.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention any conditions or exclusions, leaving the agent to infer that it's for Thimphu time specifically, but without context on when to prefer it over other time 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?

Aside from stating the output, the description does not disclose side effects, network usage, or how the many optional parameters affect behavior. Some parameter descriptions mention being discarded, but the tool description itself does not clarify whether all 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, concise sentence that immediately states the tool's purpose. There is no extraneous information or unnecessary 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?

With no output schema and no annotations, the description should have specified the return format (e.g., ISO 8601) and clarified how the optional parameters are handled. It only says 'Current UTC timestamp,' leaving important contextual details unstated.

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

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

The schema descriptions cover all 9 parameters and explicitly state that several are discarded or used only for validation. However, the tool description itself adds no parameter-level meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool's core output—a current UTC timestamp—which is enough to understand its primary purpose. It is short but unambiguous, and the tool name reinforces this meaning.

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

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

The description provides no guidance on when to use this tool, when not to use it, or how it relates to sibling time-related tools such as timezone or iana-zones. An agent would have to infer appropriate usage 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 description and parameter notes do disclose that the body is 'discarded' after the check and that 'no disk access' occurs, which gives some transparency given no annotations are present. However, it does not explain the tool's output, failure modes, or any side effects, leaving the agent guessing about the return contract.

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 main description is a single front-loaded sentence with a follow-up transparency note, making it easy to scan. The parameter descriptions, however, are cluttered with irrelevant domain hints that dilute the signal, so the overall structure earns a slight deduction.

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 input parameters and no output schema, the description leaves major gaps: it never explains what 'valid JSON' means operationally, what the tool returns (boolean, error message, or something else), or why unrelated parameters are present. An agent cannot reliably invoke this tool based on the current 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?

While the schema has 100% description coverage, the parameter descriptions are misleading: eight of nine parameters reference unrelated domains (weather hints, timezone names, RSS feeds, git refs) that do not fit a JSON validation tool. The 'json' parameter is appropriately described, but the noise from the other descriptions actively undermines the agent's ability to choose which parameter to populate.

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

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

The description states a clear verb and resource — 'Check whether a body is valid JSON' — but the term 'body' is ambiguous and doesn't explicitly map to any of the nine input parameters. It distinguishes validate-json from siblings like fetch-status or web-fetch, but the lack of a connection between 'body' and the schema leaves the core purpose unclear.

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

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

The description provides no guidance on when to use validate-json versus sibling tools such as search-query-len, fetch-status, or web-fetch. There is no mention of prerequisites, typical use cases, or situations where an alternative 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 provided, the description carries the full burden of disclosing behavior, but it only states the high-level outcome. It does not mention that the tool makes an external network call, that most of the nine input parameters are ignored, or what happens on failure or 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 a single concise sentence with no redundant wording. It states the core purpose and data source immediately, making it easy to parse.

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

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

Given the tool has nine parameters, no required fields, no output schema, and no annotations, the one-sentence description is insufficient. It omits the output format, unit of temperature, error behavior, and the fact that irrelevant parameters are ignored, so the agent does not have enough context to use the tool correctly.

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

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

Although the schema already describes each parameter, the top-level description adds only the Open-Meteo source and does not clarify the relationship between the weather purpose and the many unrelated parameters. It fails to explain that only 'city' is semantically relevant while the other eight parameters appear to be discarded or used for unrelated checks.

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

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

The description clearly identifies the tool's purpose: retrieving the current temperature for a city via Open-Meteo. It is distinguishable from sibling tools because no other sibling focuses on weather, though the lack of an explicit verb like 'gets' makes it slightly less direct.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention use cases, prerequisites, or contrast with sibling tools, leaving the agent to infer when weather-hint is appropriate.

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

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

With no annotations, the description must carry transparency. It discloses that the body is discarded and that the URL must be public, which is useful. It does not mention redirects, errors, or that the many optional params are ignored, so transparency is partial.

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

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

The description is two concise sentences with no filler. The main purpose is front-loaded and the body-discarded caveat is stated directly.

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

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

Given the complexity of a 9-parameter schema with no output schema and no annotations, the description is incomplete. It does not identify the operative parameter, explain why unrelated params exist, or describe the result format or failure 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 coverage is 100%, so baseline is 3, but the description adds no clarification for the nine optional parameters. The url parameter description ('HTTPS URL to normalize or cite') conflicts with the tool's stated fetch behavior, and parameters like city, zone, and query are not explained in the description, leaving the agent unsure which input is actually used.

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: HTTP status and content type for a public URL, with the body discarded. This is clear and distinguishes it from normalization or validation tools. However, the schema exposes many unrelated optional parameters (ref, city, zone, query), creating some ambiguity about the primary input.

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 it is for cases where only status/content type are needed and body is not, which provides some context. It does not explicitly compare itself to sibling tools like fetch-status or normalize-url, and the 'body discarded' is the only usage constraint.

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 and the description only states 'Title discarded after the call'. It does not clarify side effects, network access, read-only behavior, or error handling. The mismatched parameter descriptions further obscure what the tool actually does.

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 its brevity works against clarity. The parameter descriptions appear to be copy-pasted from other tools and add noise rather than concisely explaining the tool's actual interface.

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

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

With no output schema, no annotations, and a description that does not match the input schema, the tool definition is critically incomplete. An agent cannot reliably determine what parameters to pass or what the tool returns.

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

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

Although every parameter has a description, the descriptions are entirely inconsistent with the tool's stated purpose (e.g., 'Git ref name', 'City name', 'IANA timezone name' have no relation to checking a Wikipedia title). The schema does not include a 'title' parameter despite the tool name and description.

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

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

The description states a clear action (check whether a Wikipedia title exists) but the parameter schema contains a mismatched set of unrelated parameters (Git ref, URL, city, feed, host, JSON, path, timezone, search text) with no 'title' field anywhere. This creates significant confusion 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 guidance is provided on when to use this tool versus the many related sibling tools (browser-url-ok, fetch-status, normalize-url, etc.). The description does not mention alternatives or conditions for selection.

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