Pacific/Majuro clock

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

With no annotations, the description carries the behavioral burden. It does disclose that task text is discarded and lists the types of returned data, which is useful. However, it does not explicitly state whether the operation is read-only, requires network access, or has any side effects, leaving 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 three short sentences with no redundancy. It front-loads the primary purpose and includes only essential information, making it highly efficient.

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

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

For a tool with 9 optional parameters and no output schema, the description is incomplete. It does not explain how the parameters relate to finding a gateway, nor does it clarify when to invoke this tool. The mention of 'task text' without a corresponding parameter adds confusion. More guidance on parameter usage and invocation context is needed.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-specific meaning beyond the schema; the note about discarded task text is a general behavior, not tied to a particular parameter. It does not compensate for any gap because there is none.

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 ('Find') and resource ('public pay-per-call tool gateway (Monid)') and lists what it returns. It is distinct from siblings, though it does not explicitly contrast itself with any alternative, so it stops short of a 5.

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

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

The description provides no guidance on when to use this tool versus its many siblings. It does not mention alternatives, exclusions, or conditions for selection, leaving the agent to infer usage from the purpose alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only reveals that no browser is launched, but does not state whether the tool makes network requests, checks DNS, validates URL syntax, or has side effects. Additionally, the input schema includes parameters like 'city', 'zone', 'query', and 'json', which are unrelated to a URL check, suggesting the tool may perform multiple kinds of checks—yet the description does not explain this. This creates confusion about the actual 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 sentence—which is efficient. However, it is not front-loaded with key information; it only states the action and a single qualifier. Given the tool's complexity (9 parameters), the description is too sparse to be considered well-structured. It earns its place but does not provide a useful hierarchy or context.

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

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

The tool has 9 parameters, no output schema, and no annotations. The description is a single vague sentence that does not explain the return value, side effects, or the relationship between the 'URL' purpose and the other parameters. It is far from complete for an agent to understand what this tool does, when to call it, and what to expect. The description is insufficient for safe and 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 schema already documents every parameter. The tool description adds no parameter-specific information, so it does not improve upon the schema. The baseline of 3 is appropriate because the schema does the heavy lifting; the description does not need to repeat it. However, the schema descriptions themselves are odd (e.g., 'discarded after the shape check'), but that is outside this dimension's scope.

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

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

The description states a specific verb ('Check') and resource ('URL'), and adds a clarifying note ('No browser is launched') that distinguishes it from browser-based tools. However, the phrase 'can be opened' is vague—it does not specify whether this is a format validation, DNS lookup, HTTP status check, or something else. The scope is unclear, and it does not differentiate from siblings like fetch-status or normalize-url.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any sibling tools, prerequisites, or conditions for selection. The only hint is 'No browser is launched,' which suggests it is lighter-weight than playwright-url-ok, but that is implicit. There is no explicit when-to-use or when-not-to-use 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?

No annotations are provided, so the description carries full burden. It mentions 'Expression discarded' which hints at non-persistence, but does not disclose the actual behavior—how inputs are processed, what is checked, or what happens to each parameter. The schema descriptions note 'discarded after' for several params, but the main description does not synthesize this. It is not misleading enough to be a contradiction, but it is far from 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 extremely short (two sentences), but it is under-specified rather than concise. It lacks structure, front-loading, or any scoping. Every word is wasted because the core functionality is not conveyed. The brevity is a symptom of missing content, not efficiency.

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

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

With 9 parameters, no output schema, and no annotations, the description is woefully incomplete. It does not explain what the tool returns, how parameters interact, or what 'evaluate' means in this context. An agent would be entirely unable to predict the tool's behavior or craft a valid call. This is critically incomplete.

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

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

Schema description coverage is 100%—every parameter has a textual description in the schema. The tool description adds no information about parameters, so it meets the baseline of 3. It neither helps nor hurts; the schema already documents the parameters adequately for semantic understanding.

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 ('Evaluate') and resource ('arithmetic'), but it is misleading given the schema. The schema contains 9 unrelated parameters (ref, url, city, feed, etc.) with no arithmetic expression field. The description does not clarify what the tool actually does with these parameters, and it does not distinguish from siblings like domain-shape or file-path-ok. The purpose is unclear and potentially deceptive.

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

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

The description provides no guidance on when to use this tool, when not to use it, or which alternatives might be more appropriate. There is no mention of context, prerequisites, or exclusions. An agent would have no basis to select this tool over any of the 28 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 provided, so the description must carry the full burden of behavioral disclosure. It adds one useful note ('Page content is not stored'), but it does not disclose whether the tool makes network requests, requires permissions, handles errors, or any side effects. This is insufficient for a tool that likely interacts with external URLs.

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

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

The description is two short sentences with no redundancy. The main purpose is front-loaded, and the behavioral note is efficient. Every word earns its place.

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

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

With nine parameters, no output schema, no annotations, and many sibling tools, the description is grossly incomplete. It does not explain the return format, error behavior, how the non-URL parameters are handled, or when to prefer this over fetch-status or normalize-url. The description covers only the primary function and leaves critical context unaddressed.

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 schema already documents each parameter individually, but the description does not clarify how the many unrelated-looking parameters (city, zone, json, etc.) relate to the stated purpose of returning URL metadata. This mismatch leaves the agent uncertain about whether those parameters are used or ignored.

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: 'Return host, scheme, and HTTP status for a URL.' However, it does not distinguish this tool from sibling tools like fetch-status or normalize-url, and the input schema contains nine parameters (ref, city, feed, json, path, zone, query) that are not mentioned in the description, 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 alternatives. It does not mention any conditions or exclusions, nor does it reference sibling tools. The only additional note ('Page content is not stored') is a behavior disclosure, not usage guidance.

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

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

No annotations are provided, so the description carries the full burden. The only behavioral disclosure is 'No identifiers are retained,' which is a privacy note but does not explain how the tool processes inputs, what it returns, or any side effects. The schema hints at 'discarded after the check' for some params, but the description itself is silent. This is a minimal disclosure that fails to convey 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 concise at two sentences, and both are relevant (purpose and privacy). However, it is under-specified and lacks structure; it does not front-load the key behavioral aspects. It is not overly long, but the brevity is due to missing content rather than efficient phrasing, so a 3 is appropriate.

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 spanning diverse domains (URLs, timezones, JSON, file paths, search queries) and no output schema, the description must explain what the tool does and how to use it. The two sentences provide almost no context—no explanation of the classification logic, expected inputs, return format, or relationship to siblings. This is completely inadequate for an agent to invoke the tool correctly.

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

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

The schema provides a description for all 9 parameters, so the baseline is 3. The tool description itself adds no information about how these parameters are used together or what they mean for classification. It does not compensate or enhance the schema, but since schema coverage is 100%, it meets the baseline without additional contribution.

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

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

The description says 'Show how this request is classified' which is a purpose but is extremely vague. It does not specify what classification means, what the output is, or how it relates to the diverse parameters. The tool name 'compatibility' adds no clarity. It is not a tautology but is far from a specific verb+resource description, so it earns a 2.

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

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

There is no guidance on when to use this tool versus any of the 26 siblings. No context, no exclusions, no alternatives are mentioned. The description gives no indication of its appropriate use case, so this is a clear gap.

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 only that WHOIS/ownership is not included, but fails to describe the output format, how the nine parameters are handled, or any side effects. The behavior is largely 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 sentence with no wasted words, so it is concise and front-loaded. However, it is so brief that it omits critical behavioral details, making it under-specified 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?

Given the tool has nine parameters, many of which seem irrelevant to hostname splitting (e.g., city, feed, json), the description does not explain their purpose or relationship. There is no output schema and no description of the return value, leaving the tool inadequately specified.

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

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

The description adds no parameter-level information beyond what the schema already provides. Since schema coverage is 100%, the baseline of 3 applies, and the description does not enhance the understanding of any parameter.

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

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

The description clearly states the tool splits a hostname into labels and explicitly excludes WHOIS/ownership data, which distinguishes it from other shape-checking tools. The action and resource are specific, so 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 only provides a negative qualifier (without WHOIS/ownership) but does not name any alternative tools or state explicit conditions for when to use this tool over its siblings. There is no guidance on prerequisites or contexts.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It states a HEAD request and 'return status only,' but does not explain side effects, permissions, rate limits, or what happens with the other parameter types (e.g., whether they trigger network calls or are purely local checks). The schema parameter descriptions hint at 'discarded after the shape check,' implying no persistent effect, but this is not consolidated in the tool description.

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

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

The description is a single sentence with no filler, which is concise and front-loaded. However, it is under-specified to the point of being cryptic—it omits the tool's broader applicability and leaves the agent uncertain about the other 8 parameters. Conciseness is achieved at the cost of clarity, so it earns a middle 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 9 optional parameters, no output schema, and no annotations, the description is severely incomplete. It explains only one use case (URL status) and ignores the rest, leaving the agent without enough context to correctly invoke the tool for non-URL inputs. The return value is not described beyond 'status only,' and error conditions are absent.

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

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

Schema description coverage is 100%, so the baseline is 3 even with no parameter information in the description. The tool description adds no parameter-specific detail; it only mentions URL. The schema descriptions are somewhat vague (e.g., 'discarded after the shape check') but do exist, so the description does not need to compensate heavily. It neither improves nor detracts from the 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?

States a clear action (HEAD a public URL and return status) for a specific resource, but the description only mentions the URL parameter while the schema exposes 8 other parameters (ref, city, feed, host, json, path, zone, query) that are not addressed. This narrow framing makes the tool's full scope ambiguous and does not differentiate it from siblings like web-fetch or normalize-url.

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

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

No guidance on when to use this tool versus alternatives. Sibling tools like browser-url-ok, playwright-url-ok, and web-fetch overlap in URL handling, but the description gives no conditions, exclusions, or alternative recommendations. The agent is left to infer usage from the name alone.

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

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

With no annotations, the description carries full burden. It only mentions that the path is discarded, but gives no detail on validation, return value, error behavior, or side effects. The agent is left guessing what 'parse' actually produces.

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 (one short sentence), which is good for front-loading, but it is under-specified for a tool with 9 optional parameters. It is not verbose, but it lacks substance, so it only partially meets the conciseness ideal.

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

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

The tool has 9 optional parameters, no output schema, and no annotations. The description provides almost no context: it does not explain what the tool returns, how to invoke it, what 'parse' means, or how it relates to the schema. This is critically incomplete for an agent to use 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 coverage is 100% (all 9 parameters have descriptions), so the baseline is 3. The description adds no extra meaning about which parameter is the Figma URL or how parameters relate to the tool's purpose; it merely repeats the notion of parsing without tying it to 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 specific verb (Parse) and resource (Figma file URL), and adds a behavioral note (Path discarded). It is not a tautology and distinguishes from generic URL tools like normalize-url, though it does not name a sibling or clarify the output of parsing.

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 the many sibling shape-check or URL tools (domain-shape, github-repo-shape, browser-url-ok). It does not mention 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?

The only behavioral disclosure is 'No disk access', which is useful but insufficient. With no annotations provided, the description must carry the full burden, yet it omits what happens with the other parameters (e.g., are they validated? discarded?) and whether the tool is read-only or has side effects. The mismatch between the description's singular focus and the schema's breadth is not addressed.

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 efficient in word count. However, given the complexity of 9 parameters and the tool's potential multi-purpose nature, the brevity sacrifices critical information, making it under-specified rather than appropriately concise.

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

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

For a tool with 9 optional parameters, no output schema, and no annotations, this description is far too sparse. It does not explain the overall function across all parameters, what the tool returns, or how the safety check relates to the other inputs. The agent is left with significant uncertainty about 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?

Schema description coverage is 100% with each parameter having a clear description (e.g., 'Git ref name; discarded after the shape check'), so the baseline is 3. The tool description adds no additional parameter context beyond what the schema already provides, and it does not compensate for the wide parameter variety.

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

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

The description states a specific action ('Check whether a path looks safe') and notes 'No disk access', which clarifies the core function for the 'path' parameter. However, the input schema lists 9 unrelated parameters (e.g., ref, url, city, json), making the overall tool purpose ambiguous and failing to differentiate from sibling tools like 'browser-url-ok' or 'domain-shape'.

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

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

The description provides no guidance on when to use this tool instead of alternatives, nor any context or exclusions. With 27 sibling tools, the lack of routing information leaves the agent to guess the appropriate scenario.

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 bears the full burden of behavioral disclosure. It mentions the external service (Open-Meteo) and the output (coordinates) but omits critical details like error handling, rate limits, or how parameters like 'ref', 'url', or 'json' relate to the tool's purpose. The mismatch between the narrow description and the broad, generic schema further reduces 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 extremely short, which is not inherently bad, but it under-specifies the tool. A single sentence fails to cover the tool's behavior, parameter usage, or output. It is under-specification rather than effective 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?

Given 9 parameters, no annotations, and no output schema, the description is drastically incomplete. It does not explain how to specify a place, what the return format is, or any constraints. An agent cannot confidently invoke this tool based solely on the provided 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?

Although schema coverage is 100%, the parameter descriptions are generic and not tailored to geocoding. For instance, 'city' is described as 'City name for a public weather hint' rather than as a place name for coordinates, and other parameters (ref, url, feed, host, json, path, zone, query) appear unrelated. The tool description does not clarify which parameter carries the place input, so the schema adds little meaningful semantic guidance.

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

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

The description states a clear action and resource: obtaining latitude and longitude for a place via Open-Meteo. It is concise and informative, though it does not differentiate from sibling tools like weather-hint or timezone, which could also involve location data.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention specific scenarios, prerequisites, or exclusions, leaving the agent to infer usage solely 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?

With no annotations provided, the description must carry the full burden of behavioral disclosure. It only states the parse action but does not disclose what happens with invalid URLs, whether it returns owner/repo or a boolean shape check, error behavior, or side effects. The name 'shape' implies validation but the description does not confirm that, leaving the agent uncertain about the output and edge cases.

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 brevity. However, given the mismatch between the description and the large schema, it is under-specified and does not provide necessary context. It is concise but not well-structured to convey essential information about parameter usage.

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

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

This tool has 9 optional parameters, no output schema, and no annotations, yet the description is just one line. It fails to explain the output format, how to specify the GitHub URL among the many parameters, error handling, or any constraints. The description is grossly inadequate for an agent to invoke the tool correctly.

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

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

Although schema coverage is 100%, the description does not connect any parameter to the function. It says 'parse owner and repo from a GitHub URL' but never indicates that the 'url' parameter is the relevant one. The schema lists nine unrelated parameters, and without clarification, an agent cannot know which to populate. The description adds no value beyond the schema and actually obscures the intended 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 clearly states the verb 'parse' and the resource 'owner and repo from a GitHub URL', which is specific and distinguishes it from siblings like domain-shape or figma-url-shape. However, the schema includes many unrelated parameters (city, feed, host, etc.), so the description's narrow scope does not fully clarify that this tool likely also performs shape checks on those inputs, leaving some ambiguity about its actual coverage.

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 conditions, exclusions, or reference to sibling shape tools. An agent has no information about when github-repo-shape is preferred over domain-shape or jira-key-shape.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals only that 'Titles discarded' (presumably meaning titles are not returned), but does not disclose whether the tool performs network access, what side effects it has, error behavior, or what the actual return value looks like beyond a count. This is a minimal disclosure for a tool with potential 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 a single sentence that front-loads the primary action ('Count current Hacker News front-page stories') and includes a secondary note about titles. It is concise and well-structured, though it could benefit from more detail. It does not waste words, but it is arguably under-specified.

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

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

Given 9 parameters, no output schema, and no annotations, the description is severely inadequate. It does not explain what the tool returns (a number? a JSON object?), how the parameters affect the count, or why such generic parameters are relevant. An agent cannot confidently call this tool without guessing at the purpose of each parameter. This is far below what is needed for a tool with this 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 descriptions are complete (100% coverage) and each parameter has its own description, so the baseline is 3. The tool description adds no further meaning to the parameters; it does not explain how 'ref', 'city', 'zone', etc. relate to counting HN stories. Since the schema already explains each parameter generically, the description provides no additional value here.

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

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

The description clearly states the action: 'Count current Hacker News front-page stories.' This is a specific verb and resource, distinguishing it from sibling tools like web-fetch or fetch-status. However, the mention 'Titles discarded' adds a detail but doesn't fully clarify the tool's exact role among the many 'shape' and 'check' tools, leaving some ambiguity about its 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 guidance on when to use this tool versus alternatives. The description does not mention any conditions for selection, nor does it contrast with siblings like web-fetch or fetch-status. An agent would have to infer usage from the tool name and description alone, which is insufficient given the large sibling set.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It says only that it contains timezone names, with no mention of network calls, side effects, read-only nature, output format, or error behavior. The parameters suggest various checks (URLs, JSON, paths), but the description ignores all of that.

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

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

The description is one short sentence, but it is under-specified rather than concise. It omits essential information about what the tool does and how to use it. Efficient brevity is valuable only when the essentials are present; here it fails that test.

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, no annotations, and a one-sentence description, the tool is severely under-documented. An agent cannot determine the tool's function, expected inputs, return values, or edge cases. The description is far too sparse for the complexity of 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?

Schema description coverage is 100%, and each parameter has a clear description (e.g., 'Git ref name; discarded after the shape check'), so the baseline of 3 applies. However, the tool description does not explain how these disparate parameters relate to 'IANA timezone names', leaving the agent to guess why a timezone tool would accept a URL or city. The schema itself is informative but the connection to the tool's purpose is missing.

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

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

The description names a resource ('common IANA timezone names') and a vague context ('for clock calls'), but it never states the actual operation — does it return a list, validate a name, or something else? It also does not differentiate from sibling tools like 'timezone' or 'utc-time', leaving an agent unsure which one to pick.

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 phrase 'for clock calls' hints at a purpose but gives no conditions, exclusions, or links to sibling tools. An agent has no way to decide between this and 'timezone'.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that it returns group counts, but fails to mention that most of the 9 parameters are ignored or that the tool performs a shape check that discards many inputs. The schema hints at this ('discarded after the shape check') but the description does not, leaving significant behavioral ambiguity.

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

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

The description is a single concise sentence, which is positive, but it lacks structure and essential details. Given the tool has 9 parameters and no output schema, the extreme brevity becomes a drawback rather than an asset, leaving out critical invocation information.

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

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

The tool is highly complex with 9 parameters, no output schema, and no annotations. The description provides only the high-level purpose and none of the mechanics, making it completely inadequate for an agent to use correctly. It does not explain how to specify the robots.txt URL, what 'group counts' means, or what the response format looks like.

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

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

Despite 100% schema coverage, the parameter descriptions are unrelated to fetching robots.txt (e.g., 'Git ref name', 'City name for a public weather hint'). The tool description does not map any parameter to the URL for robots.txt, so an agent cannot know how to invoke the tool correctly. The description adds no meaningful clarification beyond the schema, and the schema's descriptions conflict with the tool's stated purpose.

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

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

The description states a specific action: 'Fetch a public robots.txt and return group counts only.' This clearly names the resource and the result. However, it does not differentiate from sibling URL-related tools like 'fetch-status' or 'web-fetch', and does not indicate which parameter supplies the URL, so it is not fully 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 offers no guidance on when to use this tool versus alternatives, nor any exclusions or context. An agent cannot determine whether to pick this over 'fetch-status' or 'web-fetch' based on the description alone.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It says 'Key discarded' but does not explain what the tool returns (e.g., boolean, error). More critically, the stated purpose (Jira key shape) does not align with the input schema, which has parameters like 'ref', 'url', 'city', etc., none of which appear to be a Jira key. This mismatch is confusing and fails to disclose how the parameters relate to the tool's function.

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

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

The description is extremely short (two sentences), which is concise, but it lacks structure and essential information. It does not explain the parameters, the return value, or how to use the tool. It is under-specified rather than efficiently concise, and the brevity does not serve the agent's needs.

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 grossly incomplete. It does not explain what the tool does with the parameters, what it returns, or how to use it. The mismatch between the description and the schema compounds the incompleteness, leaving the agent without sufficient context to invoke the tool correctly.

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

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

Schema description coverage is 100%, so each parameter is described. However, these descriptions (e.g., 'Git ref name; discarded after the shape check') are generic and do not connect to Jira key shape. The tool's description says it checks a Jira key, but no parameter is identified as that key. The parameter descriptions add little value beyond the schema and do not compensate for the lack of alignment with 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 states a specific verb and resource: 'Check a Jira issue key shape.' This clearly indicates the tool validates the format of a Jira issue key. However, it does not differentiate from sibling tools like 'domain-shape' or 'github-repo-shape' beyond the resource type, and it does not specify what constitutes a valid shape. The purpose is clear but not fully specific.

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 that it is specifically for Jira keys, nor does it state any exclusions or conditions. Sibling tools include other shape checkers, so the agent would need to infer when to choose this one. There is no explicit usage direction.

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

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

No annotations are provided, so the description carries the full burden. It only states 'Body discarded,' which is vague and doesn't clarify what happens to inputs or what is returned. The parameter descriptions hint at 'shape checks' and 'discarded after the call,' but the main description contradicts this by mentioning only HTTP status for library docs. This opacity leaves the agent uncertain about side effects, output, or constraints.

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 vague sentence. While concise, it is under-specified and lacks any structure to convey purpose, usage, or behavior. It does not earn its place because it fails to inform.

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 annotations, and no output schema, the description is severely incomplete. It doesn't explain the tool's core function, how parameters are used, or what result to expect. An agent cannot safely invoke this tool based on the provided 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 coverage is 100%, but the description adds no meaning beyond the individual parameter descriptions. It fails to connect the parameters to a coherent function or explain why they are relevant. The parameter descriptions themselves are somewhat informative but the tool description does not leverage them to clarify the overall behavior.

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

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

The description claims a specific action: 'HTTP status for a public library docs URL.' However, the tool accepts 9 unrelated parameters (city, zone, query, json, path, etc.) with no explanation of how they relate to that purpose. This mismatch makes the tool's actual function ambiguous and potentially misleading.

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 zero guidance on when to use this tool versus its 27 siblings. There is no mention of alternatives, exclusions, or conditions. An agent would have no basis to select this tool over others like 'domain-shape' 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, the description must carry the burden. It discloses that values are discarded, which is useful, but does not mention error behavior, return format, or side effects. For a simple read-only count operation, this is partial but not comprehensive.

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

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

Two short sentences, front-loaded with the core purpose, with zero fluff. The structure is highly efficient and to the point.

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 does not indicate which parameter carries the JSON input, nor what the tool returns (e.g., count as integer). With no output schema and 9 optional parameters, the agent lacks key invocation details and must inspect the schema to understand how to call it.

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 detailed descriptions for all 9 parameters, so the tool description adds no additional parameter meaning. The schema already explains each parameter's purpose and discard behavior, so the description does not need to repeat it.

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

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

States a specific verb 'count' and resource 'keys in a JSON object', and adds 'Values discarded' to clarify scope, distinguishing it from validation tools like validate-json. 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 on when to use this tool versus alternatives. It does not mention any sibling tools, conditions, or exclusions, leaving the agent to infer usage solely from the generic description.

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

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

With no annotations, the description must fully disclose behavior. It does reveal that query and fragment are dropped, which is useful, but it does not mention side effects, safety, or how the other eight schema parameters are handled (though some schema descriptions say they are discarded). It also does not state whether the operation is read-only or what happens with invalid URLs. The description is not misleading, but it is incomplete for a tool with no annotation coverage.

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

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

The description is a single, focused sentence that front-loads the core purpose and includes a key behavioral detail. There is no redundancy or unnecessary wording. It is optimally concise.

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

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

The description is insufficient for a tool with nine parameters, many of which appear unrelated to URL normalization. It does not explain how those parameters are used or ignored, nor does it specify the return format (e.g., object structure). With no output schema, an agent lacks critical information about the expected result. It also does not differentiate from many similar sibling tools, leaving the agent uncertain about when to select it.

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

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

The description adds behavioral context for the url parameter (dropping query and fragment), which goes beyond the schema's description of the parameter. However, it does not address the other eight parameters, which all have schema descriptions (some stating they are discarded). Since schema coverage is 100%, the description's added value is modest; it clarifies the main parameter's behavior but not the role of others. Baseline 3 is appropriate.

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

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

The description clearly states a specific verb ('Return') and resource ('origin, host, and path for a URL'), and explicitly notes that query and fragment are dropped. This is specific and unambiguous. However, it does not name or differentiate from sibling URL tools like domain-shape or browser-url-ok, which could overlap in purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any conditions, exclusions, or scenarios where another tool would be preferred. It is purely a functional statement with 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 carries the full burden of behavioral disclosure. It only reveals that no browser is launched, which is helpful, but it fails to describe the actual network behavior (e.g., whether an HTTP request is made), the output format, error handling, or side effects. This is insufficient for an agent to predict the tool's full behavior.

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

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

The description is extremely concise, consisting of two short sentences with no extraneous information. It front-loads the primary action and includes a key behavioral note about browser usage. Every word earns its place.

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

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

Given the tool's moderate complexity (9 optional parameters, no output schema, no annotations), the description is notably incomplete. It does not explain what 'can be opened' means in practice, the expected result, failure modes, or which parameters are actually used. The description leaves significant gaps that an agent would need to resolve through trial or additional context.

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

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

The schema descriptions cover all 9 parameters (100% coverage), so the baseline is 3. The tool description itself adds no additional meaning about how parameters relate to the URL check; it does not clarify which parameters are relevant or how they affect the outcome. The schema descriptions are informative but do not tie back to the tool's purpose, leaving some ambiguity (e.g., why city, feed, and zone are accepted).

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

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

The description clearly states the tool's purpose: to check whether a URL can be opened, with a specific verb and resource. It also explicitly differentiates itself from likely sibling tools (e.g., browser-url-ok) by noting 'No browser is launched.' This is concise and 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 versus alternatives. It does not mention any sibling tools or conditions that would favor this tool over others like fetch-status or normalize-url. There is no explicit context or exclusion, leaving the agent to infer when this tool is appropriate.

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

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

With no annotations, the description must fully disclose behavior. It only says 'Query discarded', which implies read-only and stateless, but it omits any details about the return format, error handling, or that other parameters are ignored. This is minimal and leaves the agent guessing about side effects or output semantics.

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

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

Two short sentences with no filler. The key action ('Count characters') and the fact that the query is discarded are front-loaded, making it easy to scan. No redundant content.

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

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

Given there is no output schema, the description must explain what the tool returns. It does not state whether it returns the length, a boolean success, or something else. It also fails to mention that only the 'query' parameter matters, which is essential for correct invocation with 9 optional parameters. This is a significant gap 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 description coverage is 100%, so the baseline is 3. The description adds no extra meaning to the 9 parameters; it only implicitly references the 'query' parameter via 'search query'. It does not clarify that the other 8 parameters are irrelevant, which could mislead an agent into thinking they affect the result.

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

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

The description states a specific action ('Count characters') and a resource ('search query'), making the core purpose clear. However, it does not explicitly differentiate from sibling shape-check tools (e.g., domain-shape, file-path-ok) by naming an alternative, and it leaves the return value ambiguous (just a count? a boolean?).

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 the many sibling shape-check tools. It does not state that this is specifically for query length validation, nor does it mention any prerequisites or exclusions. An agent would have to infer its scope from the name alone.

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

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

With no annotations, the description carries the full burden of behavior disclosure. It reveals nothing about side effects, return format, or what happens to inputs. The parameters (ref, url, city, etc.) are not tied to the stated purpose, creating confusion about actual 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 one short sentence, but it's under-specified rather than concise. It lacks any useful structure or front-loaded key information. It's a stub, not a concise specification.

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 severely incomplete. It doesn't explain the tool's operation, output, or relationship between parameters and the stated catalog purpose. An agent cannot confidently invoke it.

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 value and actually conflicts semantically – the parameters (ref, url, city, feed) have no obvious relation to an HTTP status code catalog. The description fails to bridge schema parameters to the stated purpose.

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

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

The description names a resource ('common HTTP status codes') but lacks a verb – it doesn't state what the tool does with them (return, validate, list). It also doesn't differentiate from siblings like fetch-status or normalize-url. The purpose is vague and disconnected from the nine parameters.

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

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

No guidance on when to use this tool versus alternatives. There is no mention of context, conditions, or exclusions. An agent would have no idea when to pick this over the many sibling tools.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the prompt is discarded, which is a behavioral trait, but it does not explain side effects, whether it is read-only, or what the template contains. Minimal disclosure.

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

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

Two short sentences, but they are under-specified rather than concise. The description fails to provide necessary context, making it not appropriately sized for the tool's complexity.

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

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

For a tool with 9 parameters and no output schema or annotations, this description is grossly incomplete. It does not explain what the template is, how to use it, why parameters exist, or what the output looks like. An agent cannot determine 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?

Schema coverage is 100%, so the schema documents each parameter's purpose. The description adds no parameter-level meaning—it merely says the prompt is discarded, which implies parameters are ignored but does not elaborate. Baseline 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?

States a specific verb and resource ('Return a three-step thinking template') but the resource is vague and the parameters are unrelated, making the actual purpose unclear. It distinguishes from siblings only by being a template provider, but not clearly.

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 the 27 siblings. The description provides no context, 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?

No annotations are provided, so the description carries the full burden. It only states what the tool returns and gives no information about network calls, permissions, side effects, or that the non-zone parameters are ignored/discarded. The description is silent on all behavioral aspects.

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 and is very concise, but it is too minimal for a tool with nine parameters. It lacks any structure or expansion that would aid an agent, making it under-specified rather than appropriately concise.

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

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

Given the tool's complexity (nine parameters, no output schema, no annotations), the description is severely incomplete. It does not indicate which parameter to use, what the output format is, whether the operation is read-only, or how to interpret the response. An agent would have to rely entirely on the schema, and the description adds almost no context.

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

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

Schema description coverage is 100%, so each parameter already has a description, including 'zone' as 'IANA timezone name'. The tool description adds no additional meaning beyond the schema, and it does not clarify that only the zone parameter is actually used, leaving the other eight parameters ambiguous to an agent that only reads the description.

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

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

The description states a specific verb ('Current time') and resource ('named IANA timezone'), making the core purpose clear. However, it does not differentiate from sibling tools like utc-time or iana-zones, so an agent might not know which to pick without further investigation.

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

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

The description gives no guidance on when to use this tool versus alternatives such as utc-time or iana-zones. It does not state prerequisites, exclusions, or context that would help an agent decide to call this tool.

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

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

With no annotations, the description must disclose behavioral traits. It only states the basic function, but the schema shows 9 parameters that are all discarded after various checks. The description fails to disclose that all parameters are ignored and that the tool simply returns the current time. This is a significant omission for a tool with such a generic parameter set.

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

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

The description is extremely concise at only two words, but it is under-specified. It does not provide structure or context beyond the bare function. While it is not verbose, it fails to earn its place by omitting essential details about parameter behavior and use cases.

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 far from complete. With 9 optional parameters, no required fields, and no output schema, the agent needs context on why these parameters exist and how they are used. The description gives no indication that they are discarded, leaving the tool's behavior ambiguous. This is a significant gap for a tool with such a complex 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?

Schema description coverage is 100%, with each parameter having a description that explicitly states it is discarded (e.g., 'discarded after the shape check'). The tool description adds nothing about parameters, but the schema already provides full semantics. Since the schema covers all parameters, 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 'Current UTC timestamp.' clearly states the tool's purpose: it returns the current UTC time. It distinguishes from sibling tools like 'timezone' which likely deals with timezone conversions, and 'iana-zones' which lists zones. However, it lacks a verb like 'get' or 'return', making it a noun phrase, but the intent 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 versus alternatives. It does not mention any prerequisites, exclusions, or comparisons to sibling tools. An agent has no information about the context in which this tool is preferred.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states that the body is discarded, but does not describe the return value (e.g., boolean success), error behavior, or side effects. It also fails to clarify which parameter is the body, making behavior 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 sentence with no wasted words, but it is overly terse and ambiguous. It front-loads the purpose but omits critical details like which parameter is the input. It is concise but not clear enough to be considered well-structured.

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

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

For a validation tool with no output schema, the description should at least mention the return type (e.g., boolean) and which parameter is being validated. It also does not explain why there are nine unrelated parameters when the tool is about JSON validation. The description is incomplete for an agent to call it confidently.

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

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

Schema description coverage is 100%, so all parameters are already documented. The description adds no additional parameter meaning and even introduces confusion by referring to a non-existent 'body' parameter instead of the 'json' field. It neither helps nor hurts beyond the schema 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+resource: check if a body is valid JSON. It is distinguishable from sibling shape-checkers like domain-shape or jira-key-shape, which validate specific formats. However, the term 'body' does not map directly to any parameter in the schema (the closest is 'json'), creating slight 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?

No guidance is given on when to use this tool versus alternatives. There is no mention of alternative tools, prerequisites, or exclusions. The description only states the action without context 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?

No annotations are provided, so the description carries the full burden. It only states the function without disclosing any side effects, constraints, or context (e.g., that it's a hint, that results are discarded, or that it makes an external API call). The description is essentially a bare assertion of functionality.

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, which is concise and front-loaded with the core purpose. It earns its place by being to the point, though it sacrifices depth 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 has 9 optional parameters and no output schema, the description is severely incomplete. It does not explain how to use the tool, what the primary 'city' parameter is for, or why other unrelated parameters are present. An agent cannot reliably call 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 the parameters are documented in the schema. The description adds no additional meaning about the parameters, which is acceptable per the baseline. However, the description does not clarify why many unrelated parameters (ref, url, json, etc.) exist in a weather tool, leaving the agent uncertain about which are relevant.

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

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

The description clearly states it provides the current temperature for a city via Open-Meteo, which is a specific verb+resource. However, it doesn't explicitly say 'get' or 'retrieve', and it doesn't differentiate from siblings beyond the weather context, which is already unique among the listed tools.

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

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

There is no guidance on when to use this tool versus alternatives, no mention of prerequisites, and no exclusions. The agent is left to infer that it is for weather queries, but no explicit routing is provided.

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

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

With no annotations, the description carries the full burden. It discloses that the body is discarded and that it works on public URLs, which is useful. However, it omits other behavioral aspects such as redirect handling, timeouts, network requirements, or whether it performs any validation beyond URL fetching. The minimal disclosure leaves significant uncertainty.

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

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

The description is a single sentence that immediately conveys the core purpose and a key behavior (body discard). It is front-loaded and contains no filler. Every word earns its place.

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

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

The tool has 9 parameters, none required, no output schema, and no annotations, yet the description only covers URL fetching. It does not explain the other parameters' purposes or how they relate to the stated function. An agent would be unable to correctly use this tool for anything beyond a simple URL check, leaving significant gaps in understanding the full scope.

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 of the 9 parameters is described in the schema. The tool description does not add any parameter-specific context beyond the schema, which is acceptable given the high coverage. However, the description fails to explain why parameters like 'city' or 'ref' exist, leaving the agent to infer their role from schema text alone.

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 HTTP status and content type for a public URL, which is a specific and actionable purpose. It distinguishes itself from likely siblings by mentioning body discard, though it does not explicitly contrast with similar tools like fetch-status or browser-url-ok. The purpose is clear but not fully differentiated from potential alternatives.

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

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

There is no guidance on when to use this tool versus alternatives. No mention of conditions, exclusions, or alternatives is present. An agent would have no indication of which tool to choose among the many URL-checking siblings.

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

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

The description discloses that the title is discarded after the call, but it does not explain which parameter is the title, nor does it mention any other behavior such as network access, rate limits, or side effects. With no annotations, the description carries full burden, and it fails to clarify the parameter mapping, leaving the behavior ambiguous. The mismatch between 'title' and the schema's lack of a title parameter is confusing.

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, which is concise, but it is under-specified. It omits critical information about parameter usage and expected output. The brevity is not effective because it does not convey enough information for an agent to correctly invoke the tool.

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

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

Given the tool has 9 parameters, no output schema, and no annotations, the description is grossly incomplete. It does not explain how to invoke the tool, what to expect as a result, or which parameter to use. This is inadequate for an agent to use the tool correctly.

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

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

The input schema has 100% description coverage, so each parameter is individually documented. However, the tool description does not add any meaning beyond the schema and fails to connect any parameter to the purpose of checking a Wikipedia title. The description mentions 'title' but none of the 9 parameters is named or described as such, creating a gap that the description does not compensate for.

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

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

The description clearly states a specific action and resource: checking whether a Wikipedia title exists. It is distinct from sibling tools that check URLs or other shapes. However, it does not clarify which input parameter carries the title, and it doesn't explicitly differentiate from tools like 'fetch-status' or 'web-fetch' that might also check existence of resources, though the Wikipedia-specific scope helps.

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 conditions, exclusions, or alternative tools. There is no context on when to prefer this over other shape-checking tools. The single sentence is purely functional without any usage direction.

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