Pacific/Fiji clock

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

No annotations are provided, so the description must carry the full burden. It discloses that it returns CLI setup, how-it-works, skill file, and remote MCP hops, and mentions 'Task text discarded.' However, it does not state whether the operation is read-only, what errors might occur, whether authentication is needed, or any side effects. This is insufficient for a tool with no annotation safety hints.

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 that communicates the main purpose and return payload. There is no wasted text, and it is easy to scan. This is exemplary conciseness.

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 having 9 optional parameters and no output schema, the description only hints at return values. It does not explain when to invoke this tool, what the parameters are for in combination, or what the returned data means. An agent would struggle to decide to use this tool correctly without additional context. The description is too sparse for the tool's complexity.

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 for all 9 parameters, so the baseline is 3. The tool description adds no parameter-specific meaning beyond the schema, and does not clarify how parameters interact or which are essential. It only notes 'Task text discarded,' which is ambiguous. Since the schema already documents each parameter, a 3 is appropriate.

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

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

The description states a specific verb ('Find') and a resource ('public pay-per-call tool gateway (Monid)'), and lists what it returns. It is clear about the core purpose, but does not differentiate from the many sibling tools like web-fetch or browser-url-ok, so it's not a perfect 5.

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

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

There is no explicit guidance on when to use this tool versus alternatives. It does not mention conditions, prerequisites, or contrast with any sibling. The usage context is only implied by the tool's name and description, leaving the agent to infer.

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 only mentions that no browser is launched, but does not disclose whether a network request is made, whether the operation is read-only, or what the outcome indicates. It also does not explain the purpose of the many parameters that are 'discarded' or how they relate to checking a URL.

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

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

The description is a single sentence with no wasted words, and the key constraint ('No browser is launched') is front-loaded. It is appropriately concise, though it could incorporate more useful information without losing 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?

For a tool with 9 parameters, no required fields, no output schema, and no annotations, this description is severely incomplete. It does not explain the purpose of most parameters, what the tool actually does beyond a vague 'check', or what the return value signifies. An agent cannot determine correct usage or expected behavior from this definition alone.

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

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

The schema descriptions cover all 9 parameters with explanations (e.g., 'discarded after the shape check'), so the schema already provides meaning. The tool description adds no parameter-level detail. However, the description fails to reconcile why parameters like 'city' or 'json' are part of a URL-check tool, which reduces the added value beyond the schema. Baseline of 3 is appropriate since schema coverage is 100%.

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

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

The description states a clear verb ('Check') and resource ('a URL'), and adds a distinguishing behavior ('No browser is launched'). However, it does not explain what 'can be opened' means precisely (e.g., HTTP reachability, format validation), and the input schema includes many unrelated parameters (city, json, path, zone, query) that the description does not account for, creating confusion 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 provides no guidance on when to use this tool versus siblings like 'playwright-url-ok', 'fetch-status', or 'normalize-url'. It only states what it does and that no browser is launched, but does not mention alternatives or conditions for selection. This leaves the agent without routing 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 must fully disclose behavior, but it only says 'Expression discarded,' which is inconsistent with the schema (no expression exists). The actual behavior implied by the schema (e.g., 'discarded after the shape check') is not mentioned, so an agent would be misled about what the tool does and what happens to inputs.

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

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

The description is extremely short (one sentence) and front-loaded with a misleading claim. While it is concise, it lacks any useful information and is not structured to help an agent understand the tool. Under-specification is not conciseness; this is unhelpfully brief.

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

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

For a tool with 9 parameters, no output schema, and no annotations, the description provides almost no contextual completeness. It fails to explain what the tool actually does, what inputs are for, what outputs to expect, or how it differs from siblings. An agent would have no basis to call it correctly.

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

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

Schema description coverage is 100%, so the schema documents each parameter's purpose. However, the description adds no parameter-level meaning and instead misleads by referencing arithmetic that is absent from the schema. The baseline of 3 is reduced because the description actively conflicts with the parameter semantics, making it harder for an agent to correctly interpret the inputs.

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 the tool evaluates 'a+b style arithmetic,' but the input schema contains no arithmetic expression parameter; instead it has 9 unrelated string parameters (ref, url, city, feed, host, json, path, zone, query). This is actively misleading and fails to convey the tool's real function, which appears to be a shape-checker or validator given the sibling tools and schema descriptions.

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

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

There is no guidance on when to use this tool versus alternatives. The description provides no context, no exclusions, and no mention of any specific use case that would distinguish it from the many sibling tools like domain-shape or validate-json.

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 must carry the full burden. It discloses one behavior ('Page content is not stored') but fails to mention that it likely performs an HTTP request, potential failure modes, rate limits, or how the other parameters (ref, city, feed, etc.) are handled. The schema indicates these are discarded, but the description does not clarify their role or side effects, leaving significant 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 concise at two sentences, but it is under-informative given the complexity of 9 parameters. It front-loads the core function but omits any explanation of the broader parameter set, making it more terse than helpful.

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

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

For a tool with 9 optional parameters, no annotations, and no output schema, the description is incomplete. It does not explain the return format beyond naming the fields, does not clarify the purpose of the other parameters, and offers no usage context. An agent would likely be uncertain about how to call 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?

While schema coverage is 100%, the description only addresses the URL parameter. The other eight parameters have schema descriptions that appear unrelated to the tool's stated purpose (e.g., 'Git ref name; discarded after the shape check'). The description does not reconcile this mismatch or add context for these parameters, so it fails to compensate for the confusion.

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

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

The description clearly states a specific verb and resource: 'Return host, scheme, and HTTP status for a URL.' It also adds a clarifying note about not storing page content. However, it does not explicitly differentiate this from siblings like 'fetch-status' or 'normalize-url', so the purpose is clear but not fully distinguished.

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. It does not mention any conditions, prerequisites, or scenarios where this tool is preferred. The note about not storing content hints at a lightweight check but does not explicitly compare to siblings.

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

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

With no annotations provided, the description carries the full burden. It only discloses that 'No identifiers are retained,' which is a privacy note, but it does not state whether the tool is read-only, performs network calls, or has any side effects. The parameter schema mentions discarding and no disk access, but that is not in the description, and the overall behavior remains opaque.

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

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

The description is two short sentences and is not verbose, but it is under-specified. The first sentence is vague and the second is a privacy note. While concise, it fails to provide enough information to be effective, so it does not earn a higher 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?

Given the tool has 9 optional parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain what the classification output is, how the parameters are used, or when the tool is applicable. The agent would need to infer behavior from parameter names and schema descriptions, which is insufficient.

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

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

Schema description coverage is 100%, and each parameter is described in the schema (e.g., 'discarded after the shape check'). The tool description adds no parameter-specific meaning beyond what the schema already provides, 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 states 'Show how this request is classified' which is vague and does not specify what 'compatibility' means or what classification is performed. It does not name the resource or action clearly, and it is indistinguishable from the purpose of several sibling tools without reading schemas.

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

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

No guidance is given on when to use this tool versus alternatives. The description does not mention any exclusions, conditions, or related tools, leaving the agent to guess from the generic name and vague purpose.

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 full responsibility. It mentions a behavioral constraint ('without WHOIS or ownership data') but fails to disclose side effects, error handling, return format, or network access. The schema notes that some parameters are 'discarded after the check,' but that is not in the description. The description is too sparse to inform safe invocation.

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

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

The description is a single, front-loaded sentence with no filler. It is efficient in communicating the core action. However, its brevity borders on under-specification, omitting essential usage and behavioral details, so it earns a high but not perfect 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?

For a tool with 9 parameters, no annotations, and no output schema, the description is severely incomplete. It does not explain the purpose of the extra parameters, return values, error behavior, or edge cases. An agent has little guidance beyond the schema, which itself is confusing given the tool's stated purpose. The description is inadequate for safe and 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?

Although schema coverage is 100%, the description adds no value about the parameters. It does not clarify which parameter (e.g., 'host') is the hostname to split, nor does it explain the role of the other eight parameters (city, feed, json, etc.) in relation to the stated purpose. This disconnect makes the description misleading and fails to compensate for the parameter diversity.

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 ('split') and resource ('hostname'), and adds a distinguishing negative ('without WHOIS or ownership data') that separates it from siblings like fetch-status or normalize-url. However, it is terse and does not reconcile with the nine heterogeneous parameters in the schema, so it could mislead an agent about the tool's actual scope.

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

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

There is no explicit guidance on when to use this tool versus alternatives. The only hint is the negative 'without WHOIS or ownership data,' which implies a limitation but does not state conditions for selection or mention any prerequisite or context. An agent would have to infer usage from the name and schema.

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. It says 'HEAD a public URL and return status only,' but does not disclose that most of the 9 parameters (ref, city, feed, json, path, zone, query) are discarded and only URL is actually used. It also doesn't mention authentication, rate limits, or response format beyond 'status.' The behavior is only partially transparent.

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

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

The description is a single sentence with no filler, and the verb and core action are front-loaded. It is appropriately concise for a simple tool, though it could arguably be expanded to clarify parameter usage. The structure is efficient and clear.

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 notably incomplete. It doesn't explain what 'status' means (HTTP status code?), how the many parameters are handled, or whether the tool has any side effects. The schema descriptions help individually, but the tool description fails to tie them together or clarify the actual input scope. An agent would struggle to know that only URL matters.

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

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

Schema description coverage is 100%, and each parameter has a clear description (e.g., 'discarded after the shape check'). The tool description adds no extra semantic value beyond the schema; it only repeats the idea of a URL. With high schema coverage, a baseline of 3 is appropriate since 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 verb ('HEAD') and resource ('public URL'), and explicitly says it returns only status. This clearly differentiates from sibling tools like web-fetch, browser-url-ok, and playwright-url-ok, which imply fetching content or full checks. The purpose is unambiguous.

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

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

The description provides no guidance on when to use this tool over the many alternatives. With siblings like web-fetch, browser-url-ok, and playwright-url-ok, there is no statement of conditions or exclusions. An agent must infer from the name and one-liner that it's for status-only checks, which is not explicit.

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

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

With no annotations, the description carries the full burden. It discloses one behavior ('Path discarded') but leaves other behaviors unexplained—such as how other parameters (city, feed, json, etc.) are handled. The tool's name suggests a shape check, but the description doesn't clarify the output or side effects.

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

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

The description is extremely brief—two short sentences with no fluff, but it is under-specified for a tool with 9 parameters. It is not wasteful, but it sacrifices necessary detail for brevity.

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

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

Given the tool's complexity (9 parameters, no output schema), the description is far from complete. It doesn't explain what 'parse' returns, how the URL is validated, or what happens to the other parameters. An agent would have little context to call it correctly beyond the schema.

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

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

The schema provides 100% coverage with descriptions for all 9 parameters, so the baseline is 3. The description adds no parameter-specific meaning beyond noting the path is discarded, which is a marginal addition over 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 states a clear action ('Parse a Figma file URL') with a specific resource, which distinguishes it from generic URL tools. However, it does not reference sibling tools or conditions for selection, so it does not fully differentiate among the many URL-related siblings.

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 normalize-url or browser-url-ok. The description only states what it does, not when to choose it or what inputs are appropriate beyond the URL.

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

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

No annotations are provided, so the description carries the full burden. It does disclose 'No disk access,' which is a useful safety property, but it omits the return format, error behavior, and what constitutes a 'safe' path. For a validation tool, this is insufficient 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 sentence, which is concise but far too terse for a tool with 9 parameters and no output schema. It lacks necessary context and structure, sacrificing completeness for brevity.

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

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

With 9 parameters, no output schema, and no annotations, the description is severely incomplete. It doesn't explain the return value, the meaning of 'safe', or the role of the additional parameters. Agents cannot reliably invoke 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 description coverage is 100%, providing descriptions for all 9 parameters, so baseline is 3. However, the description fails to explain how the many unrelated parameters (ref, url, city, feed, host, json, zone, query) relate to the stated single purpose of checking a file path, leaving agents confused about which parameter to use. This undermines the usefulness of 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 checks whether a path looks safe and explicitly notes 'No disk access,' giving a clear verb and resource. However, it does not define what 'safe' means or differentiate from sibling tools like browser-url-ok or domain-shape, so the purpose is only partially 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?

There is no guidance on when to use this tool versus the 27 sibling tools. No mention of alternatives, exclusions, or typical use cases, leaving the agent without decision support for 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 provided, the description carries the full burden of behavioral disclosure. It mentions an external service (Open-Meteo) but gives no information about side effects, rate limits, reversibility, or what happens to the passed parameters (some are marked 'discarded' in the schema, but that is not surfaced in the description). The description adds no behavioral context beyond the provider name.

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

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

The description is a single, short sentence with no wasted words. It is efficient, but it is under-specified rather than optimally concise—it omits essential usage information. The structure is clean, so it earns a 4 for brevity.

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

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

Given the tool's complexity (nine optional parameters, no output schema, and no annotations), this description is severely incomplete. It provides no information about expected input patterns, return format, or how the tool behaves with different parameters. An agent would have no way to call 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?

Although schema coverage is 100%, the description fails to connect the tool's purpose to any specific parameter. It says 'for a place' but does not indicate whether 'city', 'query', or another field should be used to specify that place. The description adds no value in disambiguating the nine optional parameters.

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

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

The description states the resource (latitude and longitude) and the provider (Open-Meteo), but the phrase 'for a place' is vague—it doesn't specify which input parameter identifies the place or how this differs from sibling tools like weather-hint, which likely also uses Open-Meteo. The purpose is recognizable but not sharply differentiated.

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, timezone, or iana-zones. The description does not mention any preconditions, exclusions, or selection criteria, leaving the agent to guess.

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 only states the core purpose and does not disclose behavior for invalid URLs, return format, or that only the 'url' parameter is used while others are discarded. The schema hints at discarding, but the description does not reinforce this.

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 is front-loaded with the purpose. It has no fluff, but is terse and omits necessary details about parameter mapping and 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?

For a tool with 9 parameters, no output schema, and no annotations, the description is incomplete. It lacks the output format, which parameter to use, and error handling. The description alone is insufficient for an agent to call it correctly.

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

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

Schema description coverage is 100%, but the description does not clarify which parameter is the GitHub URL. The schema's 'url' description is generic, and the tool description adds no mapping or additional meaning for any of the 9 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 verb and resource: 'Parse owner and repo from a GitHub URL.' However, it does not specify which input parameter is the GitHub URL. The schema's 'url' parameter is described generically as 'HTTPS URL to normalize or cite', creating ambiguity about the mapping.

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

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

No guidance is given on when to use this tool versus sibling tools like domain-shape, figma-url-shape, or jira-key-shape. There is no mention of alternatives, conditions, 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 provided, the description carries the full burden of behavioral disclosure. It only notes that titles are discarded, but says nothing about side effects, access patterns, rate limits, output format, or why the parameters exist. The tool appears read-only, but this is never 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?

The description is a single efficient sentence that front-loads the main action. It is concise and waste-free, but it is so brief that it sacrifices necessary context, so it does not earn a 5.

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

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

Given nine parameters, no output schema, and no annotations, the description is severely under-specified. It does not explain the parameters' purpose, the return value, or usage constraints, leaving the agent without enough information to call the tool confidently.

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

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

The schema has 100% coverage, so the baseline is 3, but the description adds no meaning to the parameters, and the parameters themselves (ref, url, city, feed, host, json, path, zone, query) are wildly unrelated to counting HN front-page stories. The description fails to explain their relevance, leaving the agent confused about 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?

The description states a specific action ('Count') and a clear resource ('current Hacker News front-page stories'), making the core purpose unambiguous. However, it does not differentiate from any sibling tool, and the presence of nine unrelated parameters muddies the intent, so it misses a top score.

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

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

No guidance is given on when to use this tool versus alternatives like web-fetch or fetch-status. There are no stated conditions, exclusions, or references to sibling tools, leaving the agent to infer appropriate usage entirely.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not mention return format, side effects, whether it performs I/O, or what happens with the parameters (many marked as 'discarded'). The tool's behavior is essentially opaque.

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, which is concise in length but not in substance. It is under-specified rather than efficiently informative, omitting critical details. It does not front-load actionable information.

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

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

For a tool with 9 parameters, no required fields, and no output schema, the description provides almost no context. It does not explain what the tool returns, how to invoke it correctly, or what the parameters are for. The description is severely incomplete for an agent to use it properly.

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 meaning and, worse, the parameters (ref, url, city, feed, host, json, path, zone, query) seem unrelated to 'IANA timezone names for clock calls.' This mismatch reduces clarity below baseline; the description fails to explain how these parameters relate 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 description says it provides 'common IANA timezone names for clock calls,' which hints at a list or reference, but it does not state what operation the tool performs (e.g., returns a list, validates, or transforms). It does not differentiate from siblings like 'timezone' or 'utc-time,' and the parameter list (url, host, json, etc.) does not align with a simple timezone-name list, leaving the actual purpose ambiguous.

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

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

No guidance is given on when to use this tool versus the many sibling timezone/clock tools. There is no mention of scenarios, prerequisites, or exclusions. An agent cannot infer when 'iana-zones' is the right choice.

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

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

No annotations are provided, so the description carries the full burden. It discloses the network fetch and that only group counts are returned, but it does not mention that most of the 9 parameters are discarded, potential error handling, or any side effects. The schema hints at discarding, but the description itself offers no behavioral caveats.

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

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

The description is one sentence and front-loads the core purpose, which is good for conciseness. However, for a tool with 9 parameters, it is under-specified, lacking the structure needed to clarify parameter usage. It is concise but not sufficiently 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?

The tool has 9 parameters, no annotations, no output schema, and numerous siblings. The description gives only the basic function, leaving the agent to guess how to map parameters to the fetch action and how it differs from similar tools. This is completely 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 description coverage is 100%, so the baseline is 3, but the description adds nothing about how the 9 parameters relate to the tool's purpose. Several parameter descriptions (e.g., 'url' as 'HTTPS URL to normalize or cite') conflict with the stated function of fetching robots.txt, creating confusion rather than clarity. The description should have identified which parameter is the target URL.

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

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

The description clearly states the verb (fetch) and resource (public robots.txt) and the output (group counts only). However, it does not differentiate from the many sibling tools that also fetch URLs (e.g., fetch-status, web-fetch, normalize-url), 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?

There is no guidance on when to use this tool versus alternatives. It does not state prerequisites, exclusions, or conditions that would route an agent here over a sibling like browser-url-ok or fetch-status.

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

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

With no annotations provided, the description carries the full burden. It only notes 'Key discarded', implying non-persistence, but does not disclose return values, side effects, or any operational constraints. This is insufficient for an agent to predict 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 fluff. It is appropriately sized for a trivial check, but the extreme brevity leaves out essential details, so it cannot earn a 5.

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 parameters, no required fields, and no output schema, the description is grossly incomplete. It does not specify which parameter to use, what 'shape' means, or what the tool returns. An agent would not know how to invoke it correctly.

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

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

Although schema description coverage is 100%, the description does not clarify which parameter is the Jira key. The schema descriptions are generic (e.g., 'Git ref name; discarded after the shape check') and do not link to the Jira-specific purpose. The description adds no value beyond the schema and actually introduces confusion.

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 a Jira issue key shape'), but it fails to specify which of the 9 parameters contains the Jira key, making it ambiguous. The parameter list includes unrelated fields like 'city' and 'feed', so the agent cannot confidently map the purpose to an 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?

No guidance is given on when to use this tool versus siblings like 'github-repo-shape' or 'domain-shape'. There is no mention of conditions, alternatives, or prerequisites.

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 full burden of behavioral disclosure. It mentions body is discarded, but omits that it fetches the URL, whether it is read-only, or any network/permission implications. This is minimal transparency for a tool that likely makes network requests.

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

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

The description is two short sentences, front-loaded with the core action and outcome. It is concise and to the point, though it sacrifices detail for brevity.

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

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

With 9 parameters and no output schema, the description is severely incomplete. It only mentions URLs, leaving the purpose and interplay of the other eight parameters unexplained, making it insufficient 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?

Schema description coverage is 100%, so each parameter is already documented. The description adds no extra meaning about how parameters relate to the tool's purpose, so it meets the baseline but does not enrich 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 states the tool returns HTTP status for a public library docs URL and explicitly notes the body is discarded, which gives a clear verb and resource. However, it does not differentiate from siblings like fetch-status or web-fetch, which also handle URL 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?

No guidance is provided on when to use this tool instead of alternatives. The description gives no context for selection, leaving the agent to infer based on the name and 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?

No annotations are present, so the description carries the burden. It reveals that values are discarded, which is a small behavioral hint, but it does not disclose error handling, what happens with invalid JSON, or any side effects. The schema parameter descriptions like 'discarded after the shape check' are inconsistent with the counting purpose, adding confusion.

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

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

The description is extremely short, but it lacks essential information about how to invoke the tool. It is not efficiently front-loaded; it omits the critical link between the JSON object and the parameters. Every sentence is minimal but not earning its place because it does not convey usable guidance.

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

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

With 9 optional parameters, no required inputs, no output schema, and no annotations, the description is drastically incomplete. It fails to explain how any parameter feeds into the counting operation, making the tool effectively uncallable without external knowledge. The complexity demands far more detail than provided.

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

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

Despite 100% schema coverage, the parameter descriptions do not align with the tool's purpose. The 'json' parameter is described as 'JSON text to validate' rather than as input for counting keys, and the other 8 parameters appear unrelated. The description does not clarify which parameter is the target, so the agent cannot map inputs 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?

The description states a clear action (count keys in a JSON object) but fails to specify which parameter provides the JSON input. It does not differentiate from siblings like validate-json, which also deals with JSON. The phrase 'Values discarded' adds minor detail but leaves the core usage ambiguous.

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

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

No guidance on when to use this tool versus alternatives. There are no exclusions or conditions, and the agent is left to infer from the name alone. No mention of prerequisites or preferred scenarios.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It states that query and fragment are dropped, which is a useful trait. However, it does not explain what happens to the other eight parameters—whether they are ignored, used for side effects, or produce different outputs. This gap is significant given the schema lists many 'discarded' or 'hint' 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 a single, front-loaded sentence with zero wasted words. It directly states the action and the key behavioral detail (dropping query/fragment). This is exemplary conciseness.

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 with no required ones and no output schema. The description covers only the URL-normalization aspect, leaving the purpose and behavior of the other eight parameters unexplained. An agent could easily misuse the tool or be confused about why those parameters exist. The description is insufficient for a tool with this parameter complexity.

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 a little meaning for the 'url' parameter by clarifying that normalization means extracting origin, host, and path. It does not add anything for the other parameters, but they are well-described in the schema. Thus the description provides marginal additional value.

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

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

The description clearly states the tool returns origin, host, and path for a URL and drops query and fragment. This is a specific, well-defined action that distinguishes it from URL validation siblings like browser-url-ok or fetch-status. However, it does not acknowledge the nine input parameters, several of which are unrelated to URL normalization, creating potential ambiguity about the tool's full 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?

No guidance is given on when to use this tool versus the many sibling tools (e.g., domain-shape, figma-url-shape, jira-key-shape). There is no mention of alternatives, exclusions, or typical use cases beyond the basic action, leaving the agent to infer when this is the right choice.

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

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

With no annotations, the description must carry the full behavioral burden. It discloses only one trait: 'No browser is launched.' It does not state whether a network request is made, what happens on failure (e.g., timeout, 404), whether redirects are followed, or what the return format is. This is far too little for a tool with nine parameters and no output schema.

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

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

The description is extremely brief – two sentences – which is concise but under-specified. Both sentences earn their place (the core purpose and the no-browser note), but the brevity comes at the cost of necessary detail. It is not verbose, but it is not appropriately sized because it omits critical information an agent needs to call it correctly.

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

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

The tool is complex with nine parameters, no required fields, no output schema, and no annotations. The description is just two sentences and does not explain what 'open' means, what the tool returns, or how the parameters relate to the purpose. It is severely incomplete; an agent has almost no guidance on when to use it or how to interpret results.

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, so the baseline is 3. The description adds no parameter semantics – it does not explain how parameters like 'city', 'zone', 'json', or 'path' relate to the stated purpose of checking a URL. Since the schema already documents each parameter, the description adds zero value beyond that, but the high schema coverage keeps this at 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 states a verb and resource ('Check whether a URL can be opened') but the phrase 'can be opened' is ambiguous – it doesn't clarify whether it checks HTTP status, redirects, or content validity. It also does not differentiate from sibling tools like browser-url-ok or fetch-status, which likely have overlapping purposes. The added note 'No browser is launched' gives a hint but does not specify the actual mechanism.

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 any sibling tools, exclusions, or conditions. The only implicit clue is the name, but that is not sufficient. There is no 'use this when...' or 'not for...' statement.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It does disclose that the query is discarded, but it fails to explain the behavior of the other 8 parameters (are they used or ignored?) and does not mention the return format or side effects. The schema hints at each parameter's fate, but the tool description itself is minimal.

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, which is front-loaded with the purpose. However, it is under-specified for a tool with 9 parameters; conciseness should not sacrifice essential context. It earns a 3 – it is not bloated but it is too sparse to be fully effective.

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

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

Given the complexity of 9 optional parameters, no output schema, and no annotations, the description is incomplete. It only addresses the 'query' parameter and does not explain what happens with the others, what the return value is, or any error conditions. An agent calling this tool would lack critical information.

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

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

Schema description coverage is 100% – every parameter is documented in the schema. The tool description adds no extra meaning beyond the schema; it only repeats the idea of discarding the query, which is already in the parameter description. Baseline is 3 because 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 clear verb and resource: 'Count characters in a search query.' This is specific and not a tautology. However, it does not differentiate from sibling count-like tools such as 'memory-key-count' or 'hn-front-count', so it loses a point for lacking 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 gives no guidance on when to use this tool vs. alternatives. It does not mention any conditions, exclusions, or sibling tools. The only clue is the name 'search-query-len', but the description itself provides no 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?

With no annotations provided, the description must fully disclose behavior. It does not mention any side effects or operational details, and the parameter descriptions (e.g., 'discarded after the shape check', 'public weather hint') suggest a multi-purpose check tool that contradicts the stated catalog purpose. This mismatch leaves the agent without a reliable model of the tool's 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 short sentence, but it is under-specified and lacks any structure conveying usage or purpose. It is not front-loaded with critical information and provides no actionable guidance.

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

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

With 9 optional parameters, no output schema, and no annotations, the description is severely inadequate. It does not explain what the tool returns, how parameters are used, or what behavior to expect. An agent cannot correctly invoke this tool based on the provided definition.

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

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

Schema coverage is 100%, so each parameter has a description, but the tool description adds nothing beyond the schema. The parameter descriptions themselves are internally inconsistent with the 'status codes' theme, and the description fails to reconcile them. The agent cannot infer how parameters map to the tool's function.

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 ('Short catalog of common HTTP status codes') with no verb or action, making it unclear what the tool actually does. The nine input parameters (ref, url, city, feed, host, json, path, zone, query) are unrelated to HTTP status codes, creating confusion about the tool's true function. It does not differentiate from siblings like 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. No conditions, exclusions, or alternative tool names are mentioned. The description provides zero context for invocation.

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

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

With no annotations, the description must carry the behavioral burden. It only says 'Prompt discarded' and the parameter descriptions hint at discarding, but it does not disclose side effects, return format, or any side effects. The tool appears to be a no-op template generator, but this is not explicitly 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?

The description is extremely short (two sentences), but it is under-specified rather than concise. For a tool with 9 parameters and no annotations, this is insufficient. The structure provides no context or elaboration.

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 (9 parameters, no output schema, no annotations), the description is grossly incomplete. It fails to explain what the parameters are for, what the template looks like, or when to use it, making it nearly useless for an 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 each parameter already has a description. The tool description adds no extra meaning beyond the schema, and the 'Prompt discarded' note is ambiguous – it might imply parameters are ignored, but that's not clear. Baseline 3 is appropriate since the schema handles parameter documentation.

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

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

The description states a clear verb and resource ('Return a three-step thinking template'), but the purpose is vague – it doesn't clarify what the template is for or how it relates to the tool's parameters. It does not differentiate from siblings like calc-eval or validate-json, which have distinct roles.

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. There is no mention of scenarios, prerequisites, or exclusions, leaving the agent without any direction on 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It reveals nothing about side effects, discarded parameters, error handling, or the nature of the response. The presence of eight unrelated parameters (ref, url, city, feed, host, json, path, query) is unexplained, and the description does not clarify whether these are ignored or trigger other 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 concise sentence with no fluff, which is good for front-loading purpose. However, given the tool's complexity (9 parameters, no annotations, no output schema), the brevity is not appropriate – it omits essential context and does not structure information for effective use.

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

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

The tool has 9 parameters, no output schema, and no annotations, yet the description provides only a single-purpose sentence. It fails to explain the role of the non-zone parameters, the expected return format, or any limitations. This is grossly incomplete for an agent to invoke 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 the baseline is 3, but the description adds no meaning beyond what the schema already states. It only implies 'zone' is the meaningful parameter and gives no context for the other eight, which appear unrelated to timezones. This mismatch confuses rather than clarifies the parameter set, lowering the score below 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 states a clear verb ('Current time') and resource ('named IANA timezone'), so it conveys the core purpose. However, it does not distinguish itself from sibling tools like 'utc-time', 'tz-pacific-fiji', or 'iana-zones' – an agent cannot tell when to prefer this tool over those based on the description alone.

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 its siblings, nor any exclusions or prerequisites. The description simply states what it does without any context for selection, leaving the agent to guess among several time-related 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. It states only that it returns current local time, but does not disclose whether the 'zone' parameter is used, ignored, or overridden, nor does it mention any side effects, error handling, or response format. The description is too sparse to convey expected 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 concise sentence with no filler. However, it lacks structure and is so minimal that it fails to provide necessary context, so while it is concise, it is not well-structured for an agent.

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 completely inadequate for a tool with 9 parameters and no output schema. It does not explain how to call the tool, which parameters matter, what the return value looks like, or any constraints. An agent would be unable to use it 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?

Although schema coverage is 100%, the description adds no meaning to the parameters. The schema itself describes each param, but the description does not clarify which parameter is relevant or how they relate to the tool's purpose, and it contradicts the zone param by implying a fixed zone.

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 resource (Pacific/Fiji) and an action (current local time), but it does not distinguish from sibling tools like 'timezone' or 'utc-time' that may also return time. The presence of a 'zone' parameter in the schema conflicts with the fixed-zone implication, creating 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?

No guidance is given on when to use this tool versus alternatives. It does not mention whether this is for a specific zone or generic, nor does it reference any sibling tools 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.

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

No annotations are present, so the description carries full responsibility for behavioral disclosure. It does not mention that all nine input parameters are ignored/discarded (as the schema descriptions indicate), nor does it explain why they exist. This is a significant transparency gap: an agent might reasonably think parameters matter, but they are dummy. The description does not reveal any side effects, 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 extremely concise—a single phrase with no wasted words. However, it is under-specified rather than efficiently comprehensive. It lacks key information about parameters, return format, and usage context. While short, it fails to earn its place by not conveying necessary operational details.

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 optional parameters, no output schema, and no annotations, the description is inadequate. It does not explain whether the agent should pass any parameters, what the return value looks like, or how this relates to sibling time tools. An agent cannot correctly invoke this tool 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?

Schema description coverage is 100%, so each parameter has its own description in the schema, which is a baseline of 3. However, the tool description does not add any meaning about why these parameters exist or how they relate to the tool's function. The parameter descriptions themselves say they are discarded, which is informative but confusing without a tool-level explanation. The description adds no 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 'Current UTC timestamp.' clearly states the resource and the action (returning the current UTC time). It is specific enough to convey the tool's core function, but it does not differentiate from sibling tools like 'timezone' or 'tz-pacific-fiji' which also deal with time. The verb is implicit but the purpose is unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention any conditions, exclusions, or comparisons with sibling tools. An agent has no way to know if this is the right tool for a given time-related request.

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 must disclose behavior. It only says the body is discarded, which is minimal. It doesn't mention what happens on invalid JSON, return values, errors, or any side effects. This is a significant gap for a tool with no other behavioral annotations.

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, but it lacks structure and important details. It front-loads the purpose but omits necessary context for a tool with 9 parameters. It's appropriately short but not well-structured for comprehension.

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 parameters, no output schema, and no annotations, the description is severely incomplete. It doesn't explain the purpose of the non-JSON parameters, what the tool returns, or how validation works. An agent cannot confidently call this tool correctly without additional information.

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

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

The schema descriptions cover all parameters (100%), so the description adds no additional meaning. It doesn't clarify which parameter is the 'body' or how the other parameters relate to validation. Baseline 3 applies because schema handles parameter semantics, but the description's lack of linkage is a minor miss.

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 checks whether a body is valid JSON, which is a specific verb and resource. However, it doesn't clarify what 'body' refers to among the 9 parameters, and it doesn't differentiate from sibling tools, though they are different kinds of validators. The core purpose is unambiguous but could be more precise about which parameter is the target.

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 doesn't mention any conditions, exclusions, or related tools. An agent would have no context for selecting this over other validators like browser-url-ok or file-path-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, so the description carries the full burden of behavioral disclosure. It only states the core function, but does not mention that most of the 9 parameters are ignored or discarded, nor any rate limits, response format, or side effects. The schema's per-parameter 'discarded' notes partially compensate, but the description itself is silent.

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

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

The description is a single sentence with no fluff, making it highly concise. It front-loads the core purpose. However, its brevity borders on under-specification; while it is appropriately short, it omits essential context that would make it genuinely useful.

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 9 parameters, no required fields, no output schema, and no annotations, the description is severely incomplete. It does not explain which parameters are actually used, what the return value looks like, or how to handle the extraneous parameters. An agent would struggle to call 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?

Schema description coverage is 100%, so each parameter has a description. The tool description adds the context that 'city' is the relevant parameter for temperature, which is helpful. However, it does not explicitly state that the other parameters are irrelevant or how they interact, leaving the agent to guess why ref, url, feed, etc. are present. The description adds some meaning but does not fully resolve the mismatch.

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

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

The description clearly states a specific action ('Current temperature for a city via Open-Meteo') with a concrete resource (city, Open-Meteo). It is unambiguous about the core function, but it does not differentiate from sibling hint tools like geo-hint or lib-docs-hint, which also have specific domains. The wording implies a weather-only tool, but the schema's many unrelated parameters create ambiguity.

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

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

There is no guidance on when to use this tool versus the many sibling hint tools. The description provides no conditions, prerequisites, or exclusion criteria. An agent cannot infer from this text when to select weather-hint over alternatives like geo-hint or web-fetch.

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

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

No annotations are provided, so the description must carry the behavioral burden. It does disclose that the body is discarded, which is useful, but it omits critical details such as error handling, rate limits, authentication requirements, and the fact that the schema accepts nine parameters, most of which are discarded. The description also fails to clarify the relationship between the URL and the other parameters, leaving significant 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 short and front-loaded with the core purpose, which is efficient. However, it is so terse that it omits essential context for a tool with nine parameters and many siblings. It does not earn its place by covering the full scope, so while it avoids verbosity, it sacrifices necessary information.

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

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

Given the tool's complexity (nine parameters, no output schema, no annotations, and 28 siblings), the description is grossly inadequate. It fails to explain why multiple parameters exist, when to use this tool over the alternatives, or what the response format looks like. An agent cannot reliably select and 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?

Schema coverage is 100%, with each parameter having a description (e.g., 'discarded after the shape check', 'no disk access'). The tool description adds no parameter-specific meaning, but the schema already provides sufficient semantics for each parameter. The baseline of 3 is appropriate because the schema handles the explanation, though the description could have clarified that only 'url' is the primary input.

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

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

The description states a specific action (fetch a public URL) and outcome (HTTP status and content type), which is clear. However, it does not differentiate from several sibling tools like fetch-status, browser-url-ok, or playwright-url-ok, leaving the agent unsure which tool is appropriate for a given task.

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 merely states what it does, with no mention of exclusions, prerequisites, or scenarios that favor a sibling tool.

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

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It only mentions that a 'title' is discarded after the call, but this refers to a non-existent parameter. No mention of side effects, permissions, rate limits, or what happens to the actual parameters. The description is inconsistent with the schema, which is a significant transparency failure.

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

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

The description is very short (two sentences), which is concise, but it is not effective because it omits essential information and introduces a misleading term. Conciseness is not valuable if the content is inaccurate or incomplete. The structure front-loads a claim that is unsupported by the schema, so it fails the purpose of concise 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?

This is a tool with 9 parameters, no required fields, and no output schema. The description must clarify what the tool does with these parameters and what it returns. It does neither. The single sentence about 'Wikipedia title' and 'discarded' is completely inadequate for an agent to understand the tool's functionality or decide when to use it. The gap between description and schema is severe.

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, so each parameter is described individually. However, the tool description adds no meaning to any of these parameters—it references a 'title' that is not present in the schema. The description does not explain how parameters like 'url', 'json', or 'path' relate to the tool's purpose, and it actively misleads by introducing an irrelevant concept.

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 purpose ('Check whether a Wikipedia title exists'), which is clear on its face. However, it is disconnected from the actual input schema: the schema contains 9 parameters (ref, url, city, feed, host, json, path, zone, query) and none of them is a 'title'. The description introduces a concept not represented in the parameters, making the stated purpose misleading about what the tool actually operates 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?

No guidance is given on when to use this tool versus alternatives. It does not mention any context, conditions, or exclusions. The description says nothing about preferring this tool over siblings like browser-url-ok or normalize-url, nor does it clarify what kind of input it expects.

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