URL path length, URL discarded

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

No annotations are provided, so the description must disclose behavior. It mentions returned artifacts (CLI setup, how-it-works, skill file, remote MCP hops) and that 'Task text discarded,' but does not explain side effects, authentication needs, rate limits, or how the tool processes the parameters. 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 short and to the point, which is concise, but it is under-specified. It lacks structure—no separate sections for usage, examples, or parameter roles—and the single sentence bundles multiple vague claims.

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 many siblings, this description is completely inadequate. It does not explain how to construct a valid call, what to expect in the response, or how it differs from the 28 siblings. An agent cannot reliably decide to use this tool or know what inputs to provide.

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

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

The schema provides 100% coverage with descriptions, but the tool description adds no meaning beyond that. It does not explain why these diverse parameters (url, city, json, zone, etc.) are accepted or how they relate to the gateway. The 'discarded' annotations in the schema are not reconciled with the described purpose, leaving the agent unsure of what to pass.

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

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

The description states a purpose ('Find a public pay-per-call tool gateway') and lists returned items, but it is vague ('Monid' is unexplained) and does not differentiate from siblings like citation or weather-hint. The connection to the 9 parameters is entirely unclear, making the tool's actual function confusing.

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 when/when-not conditions, no mention of sibling tools, and no context for which scenarios require this gateway.

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

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

Annotations are absent, so the description must carry the full behavioral burden. It only discloses 'No browser is launched,' which is a negative constraint. It does not state whether network access occurs, what the return value is, or how parameters like 'city' or 'zone' are involved. The mention of 'discarded' parameters implies some validation but is unclear.

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

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

The description is only two sentences with no fluff, and the second sentence is a useful differentiator. However, it is too terse to be helpful for a tool with 9 parameters and no other documentation. It is concise but under-specified, not front-loading enough 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?

This tool has 9 optional parameters, no output schema, and no annotations. The description does not explain the return value, the precise meaning of 'can be opened,' or how the parameters relate to the core function. An agent has insufficient information to invoke it correctly, making the description severely incomplete.

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

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

The input schema provides 100% parameter coverage with individual descriptions, but the tool description does not connect these parameters to the stated purpose. Many parameters (city, zone, query, json) seem unrelated to checking a URL, creating confusion. The description adds no value in explaining how these parameters are used or why they exist.

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

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

The description states a clear verb and resource: 'Check whether a URL can be opened.' It also adds a distinguishing constraint, 'No browser is launched,' which differentiates it from the playwright-url-ok sibling. However, it does not specify the exact nature of the check (syntactic, reachability, etc.) and does not explicitly name 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. With 28 siblings, the description does not indicate whether to prefer this over playwright-url-ok for a quick check or fetch-status for reachability. No when/when-not conditions are provided.

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

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

With no annotations, the description must carry the full burden, but it only mentions a non-existent 'expression' that is 'discarded'. There is no disclosure about side effects, return format, or what the parameters actually do. The description is actively misleading since it references an 'a+b style arithmetic' that has no schema representation.

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

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

The description is extremely short (one sentence), which is concise, but it is misleading and does not earn its place. It provides no useful information about the tool's actual functionality, so brevity is not a virtue here.

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 parameters, no required fields, no output schema, and no annotations. The description offers no context about what the tool does, what the parameters mean, or what the return value looks like. It is grossly incomplete 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?

Although schema description coverage is 100%, the description adds zero value to parameter understanding. It doesn't explain any of the 9 parameters or their relationship to the supposed arithmetic operation. The description contradicts the schema, so it fails to clarify parameter semantics.

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

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

The description says 'Evaluate a+b style arithmetic' but the input schema contains 9 parameters (ref, url, city, feed, host, json, path, zone, query) with no arithmetic-related field. The stated purpose does not match the schema at all, leaving the agent unable to determine what this tool actually does.

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

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

No guidance on when to use this tool versus any of the 27 siblings. The description does not provide any context for selection, and the mismatch between description and schema makes it impossible to infer appropriate usage.

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

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

No annotations are provided, so the description carries the full burden. It does disclose that 'Page content is not stored,' which is a useful privacy detail, but it omits any mention of the other parameter-driven behaviors (e.g., weather hints, JSON validation, timezone checks) implied by the schema. This creates a misleading impression that the tool only works on URLs.

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

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

The description is a single sentence with no filler. It front-loads the core action and even adds a relevant privacy note. It is appropriately concise and well-structured.

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

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

For a tool with 9 parameters and no output schema or annotations, this description is severely incomplete. It does not explain the return format, how to use the parameters, or any constraints. An agent would lack essential information to call this tool correctly beyond the most trivial URL case.

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% and each parameter has a description, so the baseline is 3. However, the tool description adds no meaning beyond the schema and fails to connect the extra parameters (city, feed, json, path, zone, query) to the stated purpose. It actually introduces confusion about how these parameters relate to returning host/scheme/status.

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

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

The description clearly states a specific verb and resource: 'Return host, scheme, and HTTP status for a URL.' This is not a tautology. However, it does not differentiate from sibling tools like fetch-status or browser-url-ok, and the input schema includes many unrelated parameters (city, feed, json, etc.) that suggest a broader scope, which muddies the 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 offers no guidance on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or contextual triggers. An agent would have no idea if this is the right tool for a given task beyond the literal URL citation 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions that no identifiers are retained, which is a privacy note, but it doesn't disclose whether the tool makes network calls, what side effects exist, or what the 'classification' output looks like. The description is incomplete for a tool with 9 parameters.

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

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

The description is very short (one sentence), but it is not front-loaded with essential information. It fails to communicate the tool's purpose clearly, so its brevity is a liability rather than an asset. It omits critical context that an agent 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 and no output schema, the description is grossly incomplete. It doesn't explain what the classification output looks like, how to interpret it, or any constraints or prerequisites. The description 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?

Schema coverage is 100%, so the input schema already documents all parameters. The description does not add any meaning beyond the schema; it doesn't explain how the parameters relate to the classification or provide any syntax or usage hints. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description states a vague purpose: 'Show how this request is classified.' It doesn't specify what classification means, what the tool actually does with the inputs, or how it differs from sibling tools like domain-shape or file-path-ok. It is not a tautology but is ambiguous and lacks a clear verb-resource pairing.

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

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

No guidance is given on when to use this tool versus alternatives. The description offers no context for selection, no exclusions, and no hints about which sibling tools might be more appropriate for specific tasks. An agent would have no basis to choose this tool over others.

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

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

With no annotations provided, the description carries the full burden. It adds only a minimal behavioral note ('without WHOIS or ownership data') but omits any side effects (e.g., discarding inputs) or output characteristics. It does not contradict annotations because there are none, 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 a single sentence, but it is under-specified rather than appropriately concise. It fails to convey essential information about the tool's scope and usage, making it inefficient 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?

For a tool with 9 parameters, no required fields, and no output schema, the description is severely incomplete. It does not explain the purpose of most parameters, what the tool returns, or when to use it, leaving agents unable to call it correctly.

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

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

The input schema describes all 9 parameters (coverage 100%), so the baseline is 3. The description adds no extra meaning beyond the schema—it only aligns with the 'host' parameter and ignores the others, providing no additional semantic value.

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

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

The description states a specific action ('Split a hostname into labels') but the input schema exposes 9 unrelated parameters (url, city, feed, json, path, zone, query). This mismatch makes the actual scope unclear—it appears to be a generic shape-checker, not just hostname splitting. It also does not differentiate from sibling shape tools like github-repo-shape or jira-key-shape.

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

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

There is no guidance on when to use this tool versus alternatives. The single sentence offers no context, no exclusions, and no mention of conditions that select this tool over its many shape-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?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only says 'HEAD a public URL and return status only', which implies a read-only operation but doesn't state what 'status' means, whether other parameters are ignored, or what happens with non-public URLs. It also fails to disclose that most parameters are discarded after a check, as the schema hints. This is insufficient for a tool with such a broad 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 short (one sentence) and front-loaded with the verb, which is good. However, for a tool with 9 parameters and no annotations, this is under-specification rather than concise. It omits essential context about the tool's multi-purpose nature and the meaning of 'status'. The brevity is not earned; it sacrifices clarity.

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

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

Given the complexity (9 optional parameters, no output schema, no annotations), the description is highly incomplete. It doesn't explain how the parameters relate to the operation, what the return value looks like, or any prerequisites. The schema provides parameter details but not the overall behavior. An agent would struggle to know what to pass or what to expect, especially when the description only mentions URL while the schema includes many other fields.

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

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

Schema description coverage is 100%, so each parameter has a clear description (e.g., 'discarded after the shape check'). The tool description adds no parameter-level meaning beyond the schema, but it doesn't detract either. Given the high schema coverage, a baseline of 3 is appropriate; the description doesn't need to repeat schema details.

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

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

The description states a specific verb ('HEAD') and resource ('public URL') and says it returns status, which gives a clear basic action. However, it contradicts the broad parameter list: the schema includes 9 optional parameters for things like city, feed, JSON, path, zone, and query, none of which are mentioned. This makes the tool's actual scope unclear and potentially misleading, so it fails to distinguish itself 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?

There is no guidance on when to use this tool versus the many sibling tools. It does not mention alternatives, exclusions, or context that would help an agent decide. The description implies a simple URL status check, but the schema suggests it may handle other 'shape checks', leaving the agent without direction.

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

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

With no annotations, the description must carry the full behavioral burden. It only discloses that the path is discarded, but omits any other side effects, return values, or checks performed. For a tool that likely validates or normalizes, this is a significant gap.

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 sentence with two clauses. It front-loads the purpose but lacks structure such as usage context or output format. It is efficient but under-specified, 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?

With 9 parameters, all optional, and no output schema, the description is woefully incomplete. It gives no indication of how the parameters relate to the Figma parsing, what a successful call returns, or any example usage. An agent cannot reliably call this tool based solely on the description.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds no parameter-specific meaning beyond what the schema already provides, so it does not improve or degrade the semantic clarity.

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

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

The description states a specific resource (Figma file URL) and a verb (parse), but it does not clarify what parsing entails or what the output is. It distinguishes from generic URL tools by naming Figma, but not from sibling shape-check tools like domain-shape or normalize-url.

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

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

There is no guidance on when to use this tool versus alternatives. The description neither mentions other tools nor provides any condition for selection, leaving the agent to infer that it applies to Figma URLs without explicit direction.

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

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

With no annotations, the description carries the full burden. It discloses 'No disk access,' which is a useful safety trait, but it fails to explain what 'safe' means, what happens when a path is unsafe, whether the tool returns a boolean or other data, or that it discards inputs after validation. The description is severely under-specified for behavioral understanding.

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 structurally efficient. However, it is under-specified to the point of being incomplete for a tool with nine parameters. Conciseness is achieved at the expense of necessary detail, so it is only adequate.

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

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

Given the tool's complexity (9 optional parameters, no output schema, no annotations), this description is grossly inadequate. It does not explain the tool's multi-purpose nature, return format, or limitations beyond 'no disk access.' An agent cannot reliably know when to invoke this tool or what to expect from 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 description coverage is 100%, so the schema already documents every parameter. The description adds no parameter-specific meaning beyond implying the 'path' parameter is relevant. Baseline 3 applies because the schema handles parameter semantics, but the description does not clarify that other parameters (url, city, etc.) are also accepted, which is a scope ambiguity the description should resolve.

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 whether a path looks safe.' This identifies the core purpose. However, it does not differentiate from sibling shape-checking tools (e.g., url-path-len, wiki-title-ok) and ignores that the schema supports many other input types (ref, url, city, etc.), so the stated purpose is narrower than the tool's actual scope.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention any conditions, prerequisites, or exclusions. The phrase 'No disk access' implies it is a safe check, but it provides no context for selecting this tool over the many related shape-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?

No annotations are provided, so the description carries the full burden. It discloses an external service (Open-Meteo) but says nothing about side effects, rate limits, or the fact that most inputs are 'discarded after the call.' The description doesn't explain what actually happens to the inputs.

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

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

A single concise sentence with no waste, but it is under-specified rather than efficiently concise. It fails to convey the actual scope of the tool, so brevity comes at the cost of correctness.

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 heterogeneous parameters, no output schema, and no annotations, the description explains none of them. Worse, the stated purpose (lat/long lookup) maps to zero parameters, so the agent has no way to understand how the inputs relate to the claimed output. Severely inadequate.

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 parameters are individually described in the schema, but the description adds zero meaning for any of them. More importantly, the description's stated purpose does not explain why 9 unrelated parameters exist or how to pick among them, so the agent cannot map inputs to the claimed 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?

States a specific verb+resource ('Latitude and longitude for a place via Open-Meteo'), but this contradicts the schema, which has nine parameters with nothing about latitude or longitude and no place input. The described purpose does not match the tool's actual inputs, so an agent would be misled about what to pass.

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 29 siblings (weather-hint, timezone, validate-json, normalize-url, etc.) which overlap heavily with the schema's parameters. No exclusions or alternative routing 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?

No annotations are present, so the description must disclose behavior. It only states the parse action, but does not mention whether it performs network calls, handles invalid URLs, or has any side effects. It also does not clarify that only the 'url' parameter is used while others are discarded.

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

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

The description is a single, efficient sentence with no fluff. It front-loads the core action and resource. However, it is so brief that it leaves important details unstated, which slightly reduces the 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?

With nine parameters, no output schema, and no annotations, the description is inadequate. It does not explain that only 'url' is meaningful, what the return value looks like, or how errors are handled. The tool appears simple, but the mismatch between the description and the broad schema creates confusion.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters. The description adds no extra meaning beyond the schema, which meets the baseline of 3 but does not compensate for the unused parameters or clarify their role.

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 ('Parse'), the resource ('GitHub URL'), and the output ('owner and repo'). This distinguishes it from sibling tools like domain-shape or figma-url-shape, which target different URL forms.

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

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

No guidance is given on when to use this tool versus the many URL-related siblings (normalize-url, browser-url-ok, jira-key-shape, etc.). The description does not mention alternatives, exclusions, or conditions for selection.

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

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

No annotations are provided, so the description carries the full burden. It discloses that titles are discarded, which is useful, but it omits any information about side effects, read-only nature, error behavior, rate limits, or how parameters affect the call. The mismatch between the described purpose and the unrelated parameters also raises transparency concerns.

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

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

The description is two short sentences, front-loaded with the core purpose and a key behavioral note. There is zero fluff; every word earns its place. It is a model of conciseness.

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

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

Despite being concise, the description is highly incomplete. It does not explain how the 9 unrelated parameters (ref, url, city, feed, host, json, path, zone, query) relate to counting Hacker News stories. Many parameters are described as 'discarded' in the schema, but the description does not clarify this or any expected usage. There is no output schema and the return format is unspecified. An agent cannot confidently invoke this tool correctly based on the description alone.

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

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

Schema description coverage is 100%, so the schema already documents each parameter's purpose (e.g., 'discarded after the shape check'). The description adds no information about parameters, so it stays at the baseline. The baseline of 3 is appropriate because the schema handles the parameter documentation.

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

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

The description states a specific action (count) on a clear resource (Hacker News front-page stories) and even adds a behavioral note (titles discarded). This is distinct from the sibling tools, which focus on validation, fetching, or formatting. The purpose is unambiguous and immediately actionable.

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

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

The description implies usage: use it when you need a count of front-page stories. However, it provides no explicit when-to-use vs alternatives, no exclusions, and no guidance on how the many parameters should be set. It relies entirely on the agent inferring the obvious use case.

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 does not explain that many parameters are ignored or discarded, nor does it describe the output format or any side effects. The schema hints at discarding inputs, but the description itself is silent, leaving significant behavioral gaps.

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

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

The description is a single sentence, which is concise, but it is too terse and fails to convey essential information. The sentence is not front-loaded with actionable content and leaves out critical details about the tool's operation, making it under-specified rather than efficiently concise.

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

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

The tool has nine parameters, no required fields, and no output schema. The description does not explain what the tool returns, how the parameters influence the result, or why they are all optional. Given the complexity and lack of structured output information, the description is incomplete and inadequate for an agent to use correctly.

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

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

Schema description coverage is 100%, and each parameter has a descriptive comment (e.g., 'discarded after the shape check'). The tool description adds no additional meaning about how parameters relate to the timezone list. Baseline 3 is appropriate since the schema already documents the parameters, though the mismatch between the tool's purpose and parameter set remains confusing.

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 'Common IANA timezone names for clock calls,' which implies the tool provides a list of timezone names. However, it lacks a clear verb (like 'returns' or 'provides') and does not differentiate itself from siblings such as 'timezone' or 'utc-time'. The ambiguity is heightened by the presence of nine unrelated parameters in the schema, making the tool's actual function unclear.

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

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

There is no guidance on when to use this tool versus alternatives. The description only mentions 'for clock calls,' which is too vague to establish selection criteria. No exclusions or explicit conditions are provided, leaving the agent without direction on 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?

No annotations are present, so the description must carry the full burden. It mentions it fetches a public robots.txt, implying a network call, but does not disclose which parameter supplies the URL, whether there are rate limits, or what 'group counts' means. It also does not mention that many parameters are discarded, although the schema hints at this.

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

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

The description is a single sentence, but it is under-specified rather than concise. It provides no structural context or parameter guidance, so the brevity is not informative.

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

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

With 9 parameters and no output schema, the description is woefully incomplete. It does not explain how parameters relate to the fetch, what the expected output format is, or what 'group counts' means. An agent cannot confidently invoke this tool based on the description alone.

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

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

Schema description coverage is 100%, but the description adds no parameter guidance. The schema descriptions themselves are ambiguous (e.g., 'url' says 'normalize or cite' rather than 'fetch robots.txt from'), and the description does not clarify which parameter is used for the fetch. Thus the description fails to compensate for the schema's lack of clarity.

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

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

The description states a clear purpose: fetch a public robots.txt and return group counts. This is a specific verb+resource that distinguishes it from sibling tools like web-fetch or fetch-status, which are more generic. However, the many parameters and their unclear relation to the fetch reduce clarity.

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 vs alternatives. There is no mention of the intended scenario, prerequisites, or which sibling tools to prefer instead. The description provides no exclusions or 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 disclosing behavior. It only says 'Key discarded', which is ambiguous and refers to a nonexistent parameter. It does not mention return values, error behavior, side effects, or what constitutes a valid key shape, leaving the agent without any operational expectations.

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

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

The description is a single sentence with no fluff, so it is concise. However, conciseness here stems from under-specification rather than efficient communication. The sentence is not front-loaded with the most useful information (which parameter to use), and it omits critical details, 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?

For a tool with 9 optional parameters and no output schema or annotations, the description is severely incomplete. It does not explain the tool's purpose beyond the vague phrase, does not map parameters to the operation, and does not describe expected outputs or failure modes. An agent cannot reliably invoke this tool without additional guesswork.

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

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

Schema coverage is 100%, so each parameter has a description, but those descriptions are generic (e.g., 'Git ref name', 'HTTPS URL', 'City name') and unrelated to Jira keys. The tool description adds no clarity about which parameter is the key or how the parameters relate to the check. Baseline 3 is reduced because the descriptions are actively misleading, failing to compensate for the disconnect between the tool's purpose and its inputs.

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

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

The description states a verb and resource ('Check a Jira issue key shape'), but the term 'shape' is undefined, and no parameter is identified as the key. With 9 unrelated string parameters, an agent cannot tell which input holds the Jira key or what a valid shape looks like. It also fails to differentiate from similar shape-check siblings like github-repo-shape or figma-url-shape.

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

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

There is no guidance on when to use this tool versus alternatives. The sibling list contains many shape-check tools, but the description offers no conditions, exclusions, or references to other tools. An agent has no way to decide whether this is the right tool for a given Jira key task.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It mentions 'Body discarded,' which is a useful trait, but it omits other behaviors like redirect handling, timeouts, authentication needs, or rate limits. It also does not clarify what happens when multiple parameters are provided, or whether the tool performs a network request at all. The description is too sparse to be transparent.

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

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

The description is a single concise sentence that front-loads the core action and the body-discard note. It is efficient with no filler. However, it is so brief that it borders on under-specification for a tool with 9 parameters, but as a standalone description it is well-structured 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?

Given the tool has 9 optional parameters and no output schema, the description is incomplete. It only addresses the URL status aspect, leaving the other parameters unexplained in context. An agent would not know why 'city' or 'zone' are relevant, or how they interact with the 'lib-docs' purpose. The description fails to cover the full scope of the tool's capabilities.

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

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

The schema provides 100% coverage with descriptions for all 9 parameters, so the baseline is 3. The description adds no parameter-specific meaning beyond the schema—it only mentions 'HTTP status for a public library docs URL' without linking to the parameters. It does not explain how ref, city, feed, host, json, path, zone, or query relate to the tool's operation, so it neither adds nor detracts from the schema's coverage.

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

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

The description states a verb and resource: 'HTTP status for a public library docs URL.' It clarifies that the body is discarded, implying a status-only check. However, it does not explain what 'lib-docs' means or differentiate this from siblings like fetch-status, browser-url-ok, or normalize-url, all of which also deal with URLs. The purpose is clear at a surface level but vague about the specific role of this tool.

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

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

No guidance is provided on when to use this tool versus its many siblings. There is no mention of alternatives, conditions, or exclusions. An agent would have to infer usage from the name and description, which is insufficient given the crowded sibling list.

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

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

With no annotations provided, the description carries full responsibility for disclosing behavior. It only says 'Values discarded' without explaining error handling, return format, side effects, or the fact that the tool accepts multiple parameters that are ignored. This is insufficient for a tool with such a broad schema.

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

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

The description is extremely short (two sentences), which is concise, but it omits essential information about parameter selection and behavior. It is under-specified rather than appropriately concise, and the information is not structured in a way that aids 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?

For a tool with 9 optional parameters and no output schema, the description is grossly incomplete. It does not explain which parameter is the JSON input, what happens if multiple are provided, or what the count result looks like. An agent cannot confidently call this tool based on the given 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%, so all parameters have descriptions. However, the tool description does not clarify which parameter holds the JSON object to count, nor does it explain why other parameters are present. The baseline of 3 is appropriate because the schema does the heavy lifting, but the description adds no semantic value beyond the schema.

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

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

The description states a specific action ('Count keys in a JSON object') but the schema exposes 9 unrelated parameters (url, city, feed, host, zone, query, etc.) that have no obvious connection to JSON key counting. This creates ambiguity about what the tool actually does, and it does not differentiate from siblings like validate-json or search-query-len.

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 use cases, exclusions, or which sibling handles similar scenarios. The description only states a bare operation without any contextual routing.

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

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

With no annotations, the description must carry the full burden. It discloses the core behavior (returning origin/host/path, dropping query/fragment) but fails to mention that the tool discards all parameters except 'url' and does not describe error handling or edge cases, leaving significant behavioral gaps.

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

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

The description is a single concise sentence that front-loads the core action. However, it is too brief to resolve the schema confusion, and a bit more structure could clarify the parameter situation without sacrificing 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?

For a tool with 9 optional parameters, no output schema, and no annotations, the description is drastically incomplete. It omits which parameter to use, the fact that all others are ignored, and the exact output format, leaving the agent with insufficient information 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 description does not clarify which parameter is the URL to normalize, even though the schema has 9 parameters with 100% description coverage. The schema itself is misleading (e.g., 'ref', 'city' are described as discarded), and the description adds no mapping between its stated purpose and the actual parameters, so the agent cannot correctly identify the input to use.

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 purpose: return origin, host, and path for a URL, and explicitly drops query and fragment. It is specific and actionable, though it does not differentiate from sibling tools like domain-shape or url-path-len.

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. With many sibling URL-related tools, the agent gets no direction on selection criteria or when not to use it.

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

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

With no annotations provided, the description bears the full burden of behavioral disclosure. It only mentions that no browser is launched, but does not clarify what actions it actually performs (e.g., network request, syntax validation), side effects, permissions, or error behavior. This is a significant gap for a tool with zero 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 concise sentence that states the core action and a key behavioral constraint. It is front-loaded and contains no fluff, though it could benefit from a bit more elaboration on what 'can be opened' means.

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 severely incomplete. It does not explain how the parameters relate to the URL check, what the return value is, or how to interpret results. An agent would not know what to do with parameters like 'city' or 'zone' when checking a URL, making this inadequate for correct invocation.

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

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

Although schema description coverage is 100%, the description adds no meaning beyond the schema. More problematically, several parameters (city, feed, json, path, zone, query) seem unrelated to the stated purpose of checking a URL, and the descriptions note they are 'discarded'—creating confusion about the tool's actual scope. The description fails to reconcile the parameter set with the stated function.

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

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

The description states a clear verb ('Check') and resource ('URL'), and includes a distinguishing note ('No browser is launched'). However, the meaning of 'can be opened' is vague—it could refer to HTTP status, DNS resolution, or mere format validation. It does not explicitly differentiate from siblings like 'browser-url-ok' or 'fetch-status', and the negative trait alone is insufficient to fully separate it.

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 neither names any sibling tools nor offers conditions for selection. An agent would have to infer usage from the description and the tool name, which is insufficient.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does reveal that the query is discarded, which is a useful side-effect statement. But it does not disclose whether the tool makes any network calls, whether it logs the query, whether it reads any local state, or what it returns (only the count? a structure?). The word 'discarded' suggests no persistence, but the absence of any statement about network access or return behavior leaves significant gaps.

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 two clauses, so it is concise and front-loaded ('Count characters in a search query'). No wasted words. However, it is so terse that it borders on under-specification; the second clause 'Query discarded' is placed after the core statement, which is acceptable. For a tool with 9 parameters and no annotations, the brevity is not a virtue because it leaves too much unsaid.

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

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

With no annotations and no output schema, the description must carry all context. It covers only the core counting behavior and the discard side-effect. It does not explain why 9 parameters exist when the tool is about counting characters in a search query — a significant contextual gap. It also doesn't specify the return value shape, edge cases (empty string, multi-line, Unicode), or relationship to sibling tools like url-path-len. The description is incomplete for a tool with this many parameters and zero annotations.

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%, meaning every parameter has a description, but the description of the query parameter only says 'Search text; discarded after the length check' — this adds little beyond the schema's own text. It doesn't explain how the query string is interpreted (e.g., raw characters vs. trimmed, Unicode code points vs. UTF-16 code units, whitespace handling). The other parameters (ref, url, city, feed, host, json, path, zone) are documented in the schema but the description doesn't clarify why they exist in a search-query-len tool or whether they are all similarly discarded. The description fails to add meaningful semantics beyond what the schema already provides.

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

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

The description states a verb ('Count') and a resource ('characters in a search query'), and adds a scope constraint ('Query discarded'). However, the tool name search-query-len is clear enough that the description merely restates the name, and it does not clarify what aspect of the query is counted (characters? tokens? bytes?) beyond the word 'characters'. It also doesn't distinguish itself from sibling tools like url-path-len or validate-json beyond the name, so the description adds little clarifying value.

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 one behavioral note ('Query discarded') but no when-to-use guidance. It does not state when to choose this over sibling tools like calc-eval or validate-json, nor any context like 'use when you only need a length check'. The 'discarded' note is a privacy/usage hint but not a usage guideline. No prerequisites or examples are given.

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

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

No annotations are provided, so the description carries the full burden of disclosing side effects, auth requirements, rate limits, or return behavior. It states none of these, and for a tool with 9 parameters, the absence of any behavioral information is a significant gap.

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

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

The description is a single short sentence, which is concise in length but not in information value. It under-specifies the tool to the point of being unhelpful, failing to earn its place by conveying any actionable detail. Front-loading is irrelevant when the content is a tautology.

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

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

With 9 parameters, no required fields, no output schema, and no annotations, the description is completely inadequate. An agent cannot determine what to pass in, what the tool returns, or how it fits into a workflow. The sibling context includes similar tools like 'fetch-status', but the description gives no differentiation.

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

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

The input schema provides descriptions for all 9 parameters (100% coverage), so the baseline is 3. However, the tool description does not connect these parameters to the 'catalog of status codes' concept—there is no 'code' parameter, and the parameters like 'city' and 'zone' seem orthogonal. The schema descriptions themselves are generic ('City name for a public weather hint') and don't explain how they relate to the tool's stated purpose, so the description adds no value beyond the schema.

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

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

The description 'Short catalog of common HTTP status codes' merely restates the tool name and provides no verb or resource. It doesn't specify whether the tool returns a code, lists codes, or validates a code, leaving the agent uncertain about its primary function. The presence of unrelated parameters like 'city' and 'zone' further muddles the 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?

There is no guidance on when to use this tool versus siblings such as 'fetch-status' or 'web-fetch'. The description does not mention any context, alternatives, or exclusions, leaving the agent to guess which tool fits a given 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, the description must carry full behavioral disclosure. It says 'Prompt discarded' but fails to explain that the tool likely ignores all input parameters or returns a fixed template. The per-parameter 'discarded' notes imply input is ignored, but this is not clearly stated, and the phrase 'Prompt discarded' is misleading since no prompt parameter exists.

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 and front-loaded with the core action, but it lacks essential information. It is concise in length but under-specified, so the conciseness is not effective—it omits context that an agent 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?

Given 9 optional parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain what the three-step template is, what the parameters do, how they are validated, or what the tool returns beyond a vague template. An agent has no way to understand the tool's behavior or proper invocation.

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

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

Schema coverage is 100%, so each parameter has a description, but those descriptions only say 'discarded after...' which adds little meaning. The descriptions do not clarify why the parameters exist, whether they are validated, or how they affect the returned template. The agent cannot determine if it should provide any of these parameters. This is confusing rather than helpful.

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

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

The description states a clear verb and resource: 'Return a three-step thinking template.' However, the clause 'Prompt discarded' is ambiguous—there is no prompt parameter in the schema, so the agent may be confused about what input is expected. It does not differentiate this tool from siblings like calc-eval or citation.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention any context, prerequisites, or conditions that would help an agent decide to call think-steps over other tools.

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

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

No annotations are present, so the description must carry the full behavioral burden. It merely states the function without disclosing any side effects, parameter handling, or what happens with the many unrelated parameters. The schema descriptions hint at discard behavior, but the tool description itself is silent.

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

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

The description is a single sentence, which is concise, but it is severely under-specified. It lacks critical information and does not front-load any guidance beyond the basic function, making it more of a tautological statement than a useful 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?

With nine parameters, no output schema, and no annotations, the description is completely inadequate. It does not explain the intended use of the other parameters, the return format, or any behavior, leaving the agent unable to call the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds no value beyond the schema. It fails to clarify that 'zone' is the primary parameter or explain the roles of the other eight parameters, leaving the agent confused about which to supply.

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 core action: retrieving the current time for a named IANA timezone. However, it does not differentiate from sibling tools like 'utc-time' or 'iana-zones', and the presence of eight unrelated parameters in the schema muddies the purpose.

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

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

No guidance is provided on when to use this tool versus alternatives, nor any conditions for exclusion. The description offers no context for selecting this tool over siblings like 'utc-time' or 'iana-zones'.

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

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

With no annotations, the description must disclose behavior, but it only mentions 'URL discarded' without explaining side effects, return format, or which parameters are actually consumed. The tool's safety profile (e.g., network access, disk access) is completely undisclosed.

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

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

The description is extremely short, but this is under-specification rather than conciseness. It conveys no meaningful structure or front-loaded action, and the phrase 'URL discarded' is cryptic.

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 grossly incomplete. An agent cannot determine what to pass, what the return value is, or whether it's safe to call. The 'URL discarded' hint is ambiguous and unexplained.

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 nothing about how the 9 parameters relate to 'URL path length'. Some params (city, zone, json) seem irrelevant, and the schema descriptions themselves (e.g., 'normalize or cite') conflict with the tool's apparent purpose, making it hard to know what to pass.

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

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

The description 'URL path length, URL discarded' is a noun phrase without a verb, making it unclear what the tool actually does. It could imply measuring a URL's path length, but it doesn't explicitly state the action or output. It fails to distinguish from siblings like normalize-url or domain-shape, which also deal with URLs.

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

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

There is no guidance on when to use this tool versus the many siblings (e.g., normalize-url, browser-url-ok, domain-shape). No context, prerequisites, or exclusions are provided, leaving the agent to guess.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description only states the output and gives no information about side effects, authentication, rate limits, or how parameters influence behavior. The schema parameter descriptions mention values being 'discarded' or 'no disk access', but these are not in the tool description. The tool's actual behavior beyond returning a timestamp is entirely 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 very concise, a single short sentence, which is efficient. However, it is under-specified; it lacks any detail that would help an agent understand the tool's complexity given its 9 parameters. Conciseness is good, but the description is too sparse to be useful. It earns a middle score because it is succinct but not adequately informative.

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

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

For a tool with 9 parameters, no output schema, and no annotations, the description is grossly incomplete. It does not explain what the returned timestamp looks like (format, precision), whether parameters are required or optional, or how they affect the result. The presence of many unrelated parameters and the lack of any explanation make the tool nearly unusable without external knowledge. The description provides no context to guide correct invocation.

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

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

Schema coverage is 100% and each parameter has a description, but the descriptions are odd and not aligned with the tool's purpose. For instance, 'city' is described as 'City name for a public weather hint; discarded after the call', and 'url' as 'HTTPS URL to normalize or cite'. These suggest the tool does validation or other processing unrelated to getting the current time. The tool description adds no clarification about how these parameters relate to the UTC timestamp, leaving the agent confused about why they exist. The baseline of 3 is reduced because the parameter semantics are misleading.

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 core function with a specific verb and resource. It is unambiguous about what is returned, though it does not distinguish itself from sibling tools like 'timezone' or 'iana-zones', which may offer similar functionality. The purpose is clear, but differentiation is absent.

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 context, prerequisites, or exclusions. An agent has no basis for selecting this tool over the 'timezone' or 'iana-zones' siblings. No when-to-use or when-not-to-use information 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 of behavioral disclosure. It mentions that 'The body is discarded', which is a positive disclosure, but it fails to describe the return value (e.g., boolean success/failure), any error behavior, or the role of the other eight parameters. The description is silent on side effects, permissions, or whether the tool modifies any state, making it insufficient for a tool with no annotations.

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

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

The description is two sentences with no filler. The core purpose is front-loaded ('Check whether a body is valid JSON') and the disposal note is concise. Every word earns its place, 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?

Given the complexity of 9 optional parameters, no annotations, and no output schema, the description is markedly incomplete. It does not specify what the tool returns, how the 'body' maps to the schema's parameters, or why unrelated parameters exist. An agent cannot confidently call this tool correctly without inferring which parameter is the JSON body and what response to expect. The description leaves significant gaps that could lead to misuse.

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

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

The schema has 100% description coverage, so each parameter is documented. The description adds 'The body is discarded' which partially aligns with the 'json' parameter's schema description ('discarded after the check'), but it does not add new meaning beyond the schema. The description does not clarify why the tool accepts many unrelated parameters (e.g., 'city', 'url'), leaving the semantics of those parameters unexplained in the description itself. Since the schema covers the basics, a baseline of 3 is appropriate.

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

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

The description clearly states the verb 'Check' and the resource 'a body' with the specific validation for JSON. It is not a tautology and conveys the core function. It does not explicitly differentiate from sibling validation tools like 'file-path-ok' or 'url-path-ok', but the JSON focus is unambiguous. The phrase 'The body is discarded' adds clarity about the tool's non-preserving nature.

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

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

There is no explicit guidance on when to use this tool versus alternatives. The description does not mention conditions, exclusions, or alternative tools. The only implicit usage is that it checks JSON validity, but no context is provided about when an agent should prefer it over other validation tools or how it relates to the many unrelated parameters in the 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?

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only states the basic function and doesn't mention that only 'city' is relevant, that other parameters are ignored, or describe the return format or side effects.

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

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

The description is a single, front-loaded sentence with no wasted words. It is concise and to the point, though extremely minimal.

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

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

With nine parameters and no output schema, the description is too sparse to support correct usage. It doesn't explain the role of the other parameters or the return structure, leaving an agent to guess which inputs matter.

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

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

Schema coverage is 100%, so the baseline is 3. The description does not add extra meaning beyond the schema, and it fails to clarify why nine parameters exist when the purpose implies only 'city' is used.

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

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

The description clearly states the tool returns the current temperature for a city via Open-Meteo, using a specific verb and resource. It is unambiguous, though it doesn't explicitly differentiate it from sibling tools.

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

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

No guidance is given on when to use this tool versus alternatives. There is no mention of conditions, exclusions, or which sibling tools it might be preferred over.

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 body is discarded and that only status and content type are returned, but it does not mention auth requirements, rate limits, or what happens with non-URL inputs. The mismatch between 'public URL' and the schema's many non-URL fields further obscures 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 at one sentence, but it is under-specified for a tool with nine parameters and no annotations. The single sentence lacks structure and does not front-load key guidance. It is not effectively concise; it simply omits necessary information.

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

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

Given the high complexity (9 params, no output schema, no annotations), the description is severely incomplete. It does not explain return values, parameter selection, or usage context. An agent would be unable to correctly invoke this tool without additional external knowledge, making the description inadequate.

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. However, the description does not add any meaning beyond 'public URL' and does not explain how the nine parameters relate to the operation. It fails to identify which parameter is the primary URL or why city, json, path, etc. are accepted. This creates ambiguity that the schema alone cannot resolve.

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+resource: HTTP status and content type for a public URL. However, it is ambiguous because the input schema allows many non-URL parameters (city, json, path, zone, query), creating confusion about the tool's actual scope. It does not differentiate from sibling tools like fetch-status or normalize-url.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention any of the 27 sibling tools, nor does it give conditions for selection. An agent cannot determine whether to use web-fetch or fetch-status for a given task.

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 mentions that the title is discarded after the call, which is trivial. It does not state whether network access is involved, error behavior, read-only nature, or any side effects – leaving the agent with no expectations beyond the bare purpose.

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

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

The description is a single sentence, which is concise, but it is far too sparse to be helpful. It omits essential details like parameter mapping and output expectations, so it is under-specified rather than appropriately sized.

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 grossly incomplete. It fails to explain how the parameters relate to the task, which parameter holds the title, what the return value indicates, or any operational details. An agent cannot call this tool correctly 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?

Although schema description coverage is 100%, the parameter descriptions are generic (e.g., 'Git ref name', 'Public hostname') and have no apparent connection to checking a Wikipedia title. The tool description adds zero parameter meaning and fails to indicate which parameter carries the title, making the tool effectively unusable from the schema 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 states a clear purpose: checking whether a Wikipedia title exists. However, it does not differentiate from sibling tools and, critically, does not connect the purpose to any of the 9 input parameters – none of which is a title. This creates ambiguity about how to invoke the tool.

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

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

There is no guidance on when to use this tool versus alternatives like 'browser-url-ok' or 'normalize-url'. No context about prerequisites, exclusions, or selection criteria is provided.

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