Pacific/Tahiti clock

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 'Task text discarded' and lists return items, giving some behavioral context. However, it does not state whether the tool is read-only, has side effects, or any permission/rate limits. For a 'find' tool it is likely safe, but this is not explicit. The description adds partial transparency but lacks depth.

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

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

Two concise sentences that front-load the purpose and immediately list return items and the input-discard behavior. No filler or redundant phrasing; every sentence earns its place.

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

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

For a tool with 9 optional parameters and no output schema, the description explains the core purpose and returns, which is adequate. However, it does not clarify which parameters are relevant to the gateway lookup or why an agent would choose this over other tools. The schema covers parameter details, but the overall context of when and how to use this tool is incomplete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add any parameter-specific meaning beyond what the schema already provides. It mentions 'Task text discarded' which relates to input handling but not to any specific parameter. No value is added 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?

Description clearly states the verb 'Find' and a specific resource: 'public pay-per-call tool gateway (Monid)'. It lists concrete outputs (CLI setup, how-it-works, skill file, remote MCP hops) and distinguishes it from sibling tools which are mostly shape/ok utilities. No ambiguity about what this tool 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?

The purpose implies when to use it (when a gateway is needed), but there is no explicit guidance on when not to use it or how it differs from alternatives. The description does not mention exclusions or contrasting sibling tools, so usage is implied rather than stated.

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

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

With no annotations, the description carries full burden. It only adds 'No browser is launched,' but does not disclose what the tool actually does (e.g., makes an HTTP request, checks DNS, returns a boolean), what parameters affect the check, or any side effects. Minimal and incomplete.

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

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

Two sentences with zero waste, but it is under-specified for a tool with 9 parameters. The concise style is appropriate in length but lacks critical information, making it insufficient 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 drastically incomplete. It does not explain the role of the parameters, the meaning of 'can be opened,' or the return value, leaving the agent unable 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 parameters are individually described, but the tool description adds no clarification on how the parameters relate to URL checking. The parameter descriptions themselves seem mismatched (city, json, path, zone), and the description does not resolve this confusion, offering no added meaning 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?

States a clear verb and resource ('Check whether a URL can be opened') but does not specify what 'can be opened' means (HTTP status, reachability, validity). The 9 unrelated parameters (city, json, path, zone) confuse the purpose, and the description does not differentiate from siblings like 'playwright-url-ok' or 'fetch-status'.

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

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

No guidance on when to use this tool versus alternatives. The description does not mention context, prerequisites, or exclusions, leaving the agent to guess which sibling fits.

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 says 'Expression discarded,' but does not reveal that the tool likely validates shapes of inputs, performs no arithmetic, or that all inputs are ignored after checks. The description is misleading about actual behavior.

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

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

The description is extremely short, but brevity here is not effective conciseness—it omits essential information. It does not front-load any useful context and leaves the agent with a confusing, incomplete picture.

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 annotations, no output schema, and a description that mismatches the schema, the definition is grossly inadequate. An agent cannot determine correct invocation or expected behavior.

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

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

Although schema coverage is 100%, the description adds no meaning to the parameters. It mentions 'a+b' but there is no parameter for an expression, and it fails to explain why the listed parameters exist or how they relate to arithmetic. The description actively confuses rather than clarifies parameter usage.

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

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

The description claims to evaluate 'a+b style arithmetic' but the schema has no expression parameter—instead it lists nine unrelated string parameters (URL, city, feed, etc.) each marked as discarded. The purpose is vague and inconsistent with the actual schema, making it hard for an agent to know what this tool 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. No mention of conditions, exclusions, or alternatives. The description gives no context for selecting this tool.

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

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

No annotations are provided, so the description carries the full burden. It does disclose that page content is not stored, which is useful, but it does not clarify whether the tool fetches the URL, how errors are handled, or what happens with the other parameters. The single behavioral note is insufficient given the scope of the tool.

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 not well-structured or informative. It front-loads the core action but omits necessary context about the other parameters and the tool's broader behavior. It is minimal but not effectively 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?

With 9 parameters, no output schema, and no annotations, the description is incomplete. It explains only the URL behavior, leaving the other eight parameters unexplained, and does not describe the return format beyond host/scheme/status. An agent cannot safely invoke this tool for non-URL inputs.

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 the baseline is 3. The description adds no extra meaning beyond the schema; it only references the URL implicitly. It does not clarify the roles of ref, city, feed, etc., which are described in the schema but remain unexplained in the tool description.

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

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

The description states a clear verb and resource ('Return host, scheme, and HTTP status for a URL') but is narrowly focused on the URL parameter, ignoring the other eight parameters in the schema. This creates ambiguity about the tool's full purpose; it does not mention citation, despite the tool name, nor does it differentiate from siblings like fetch-status or normalize-url.

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

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

No guidance is given on when to use this tool versus alternatives. It does not state conditions, exclusions, or mention sibling tools. An agent cannot decide whether to call this or browser-url-ok, fetch-status, or normalize-url without further 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, the description carries the full burden of behavioral disclosure. It only says 'No identifiers are retained,' which is a privacy guarantee but not an explanation of what the tool does. It does not state whether the operation is read-only, what output is produced, or how the input is processed. The parameter descriptions imply checks, but the main description 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 short and front-loaded, but its brevity is a weakness rather than a virtue. It is under-specified to the point of being unhelpful, so the two sentences do not earn their place by conveying 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?

This is a 9-parameter tool with no output schema and no annotations, yet the description gives almost no context about what the classification means, what output to expect, or when to use it. The tool is far too complex to be served by such a minimal description.

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

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

The input schema already describes each of the 9 parameters with 100% coverage, so the baseline is 3. The description adds no additional meaning about how the parameters relate to the classification or how they should be formatted beyond what the schema already says.

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 ('Show how this request is classified'), but it is vague about what classification means. It does not differentiate from the many specific shape-checking siblings like domain-shape or github-repo-shape, leaving an agent unsure what this tool does that they do not.

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

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

There is no guidance on when to use this tool versus any of its siblings. It does not mention conditions, exclusions, or alternatives, so an agent cannot decide whether to call this or a more specific tool.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the core action but fails to mention that the tool likely discards several parameters (as indicated in the schema descriptions) or clarify how it handles the nine different inputs. The lack of any side-effect or limitation note beyond 'without WHOIS' leaves significant ambiguity.

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

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

The description is a single, front-loaded sentence that states the core purpose immediately. It contains no filler and is appropriately concise for the information it conveys.

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

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

Despite the high schema coverage, the description is incomplete for a tool with nine parameters, many of which are unrelated to the stated purpose (e.g., city, feed, json). It does not explain why these parameters exist or how they relate to the tool's behavior, leaving an agent uncertain about which input to use or what the tool does with the others. The presence of these parameters suggests a broader function not captured in 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 each parameter has a description. The tool description adds no parameter-level detail, but the schema already documents 'host' as the public hostname and marks others as discarded. Since coverage is high, a baseline of 3 is appropriate; the description does not compensate for any gaps but also doesn't need to.

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 ('split a hostname into labels') and the resource ('hostname'), and explicitly notes the absence of WHOIS/ownership data, which distinguishes it from sibling tools like github-repo-shape or figma-url-shape. The verb-resource pair is specific and unambiguous.

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

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

The description implies a use case (when you need hostname labels without ownership info) but provides no explicit guidance on when to choose this over alternatives, nor does it mention any exclusions or prerequisites. It does not reference sibling tools or conditions that would direct an agent.

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 states 'HEAD a public URL and return status only,' but does not explain what happens when other parameters are provided, whether parameters are mutually exclusive, or what 'status' means. The schema hints at many discarded values, but the description omits this entirely.

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 underspecified to be considered well-structured. It lacks any context about the tool's polymorphic behavior and does not front-load key constraints. It is not 'appropriately sized' for a 9-parameter tool.

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

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

For a tool with 9 optional parameters, no output schema, and no annotations, the description is grossly incomplete. It does not explain how parameters map to different operations, what the expected output format is, or how to distinguish this from similar sibling tools. An agent cannot reliably determine how to invoke it correctly beyond the single 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 description coverage is 100%, with each parameter having a meaningful description (e.g., 'discarded after the shape check'). The tool description adds no additional parameter semantics. The schema itself adequately documents individual parameters, so 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 identifies a specific action (HEAD a public URL) and a specific outcome (return status only). However, the input schema contains 9 unrelated parameters (city, zone, json, etc.) that the description does not mention, so it fails to convey the tool's full scope and could mislead an agent into thinking it only handles URL status checks.

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 its many siblings (e.g., normalize-url, validate-json, timezone). It does not specify conditions for selection or exclusions, leaving the agent to infer usage from the parameter names.

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

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

No annotations are present, so the description carries full responsibility. It discloses only that the path is discarded, leaving out side effects, required inputs, error behavior, or what constitutes a valid Figma URL. This is insufficient for a tool with 9 optional 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 extremely short (two sentences), which is concise but under-specified. It front-loads the primary purpose but omits essential context about usage and parameters. Conciseness alone doesn't compensate for the lack of structure needed for a tool with this complexity.

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

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

Given 9 parameters, no annotations, and no output schema, the description is severely incomplete. It doesn't explain what the tool returns, which parameters are relevant, how to construct a valid input, or any error conditions. An agent cannot reliably call this tool correctly.

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

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

Schema description coverage is 100%, so every parameter has a textual description in the schema. The tool description adds no additional parameter meaning beyond what the schema already provides, meeting the baseline for high coverage. However, it doesn't explain which parameters are relevant to the primary purpose.

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

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

The description clearly states a specific verb ('Parse') and resource ('Figma file URL') and includes a key behavioral detail (path discarded). It distinguishes from sibling tools like normalize-url and browser-url-ok. However, it's terse and doesn't clarify what 'parse' produces or how the many schema parameters relate.

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

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

No guidance on when to use this tool versus alternatives. There is no context about typical use cases, prerequisites, or exclusions. The description implies a specific input type but doesn't say when to choose it over other URL-handling tools.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It only states 'No disk access,' which is a useful safety note, but it fails to explain what constitutes a 'safe' path, what the return value looks like, whether it is read-only, or any side effects. This is insufficient for a tool that performs validation.

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

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

The description is extremely concise, two short sentences, and front-loads the primary action. It is efficient but arguably too sparse to be helpful. Still, as a conciseness metric, it earns a 4 for zero redundancy.

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

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

For a tool with 9 parameters, no required fields, no output schema, and no annotations, the description is woefully incomplete. It does not explain the tool's full behavior, how to invoke it for different parameter types, what results to expect, or how it relates to the broader toolset. This is a serious deficiency for an agent that must decide when and how to call it.

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

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

Although the schema descriptions are clear and coverage is 100%, the tool description only mentions 'path' and ignores the other 8 parameters. This creates confusion about whether the tool also validates refs, URLs, JSON, etc., and under what circumstances. The description does not explain how to use the tool for non-path inputs, so it fails to compensate for the schema's breadth.

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

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

The description clearly states the tool's purpose: checking whether a path looks safe, with a specific verb and resource. It distinguishes this from siblings like browser-url-ok or domain-shape, which focus on URLs or domains. However, the description doesn't clarify why the schema includes 9 unrelated parameters, which slightly muddies the core 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. The description does not mention any exclusions, prerequisites, or conditions that would lead an agent to choose this tool over others. Given the long sibling list, this absence is a notable gap.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only mentions that it uses Open-Meteo, implying an external network call, but does not disclose that most parameters are discarded, what happens with multiple inputs, or any side effects or constraints.

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

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

The description is a single sentence, extremely concise, but it omits essential information needed to invoke the tool correctly. This is under-specification rather than efficient conciseness; it does not front-load any actionable detail.

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

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

Given the tool's complexity (9 parameters), the lack of annotations, and no output schema, the description is grossly incomplete. It fails to explain how to specify the place, what the return value looks like, or how the many other parameters are handled, making it nearly impossible 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?

The schema description coverage is 100%, with each of the nine parameters individually described. The tool description adds no semantic value beyond that; it does not clarify which parameter is the primary one for the place, leaving the agent to guess among city, query, or others.

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

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

The description clearly states the tool returns latitude and longitude for a place via Open-Meteo, which is a specific verb and resource. However, it does not specify which of the nine input parameters corresponds to 'a place', nor does it differentiate itself from siblings like weather-hint that also handle city data.

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

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

There is no guidance on when to use this tool instead of alternatives, no conditions for selection, and no indication of which parameter to supply for the place. The description is a bare statement without any usage context.

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

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

No annotations are provided, so the description must disclose behavior. It only says 'parse owner and repo' without stating what happens on invalid input, whether the tool validates the URL, what the return format is, or why the schema includes nine unrelated optional parameters (e.g., city, feed, json). The description does not address these behavioral aspects, leaving significant gaps for an agent.

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

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

The description is a single, focused sentence with no filler. It is front-loaded with the action and resource, making it easy to scan. Every word contributes to the purpose.

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

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

Despite the tool appearing simple, the context is incomplete. With nine optional parameters and no required ones, the description does not specify which parameters are needed or how they interact. There is no output schema, and the description fails to explain what the tool returns (e.g., owner and repo as separate fields, a combined string, etc.). The presence of unrelated parameters like 'city' and 'feed' is unexplained, leaving an agent uncertain about the actual expected input and behavior.

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

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

Schema description coverage is 100%, but the schema does not mention owner or repo. The description adds the concept of extracting owner and repo, but it does not clarify which parameter (likely 'url') is the primary input or how the other parameters relate. This creates ambiguity; for example, the schema describes 'url' as 'HTTPS URL to normalize or cite', not specifically for GitHub parsing. The description provides some added meaning but does not fully reconcile the mismatch.

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

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

The description clearly states the tool's function: parse owner and repo from a GitHub URL. It uses a specific verb ('parse') and resource ('owner and repo'), and the mention of 'GitHub URL' distinguishes it from sibling tools like figma-url-shape and jira-key-shape. Though it doesn't explicitly name alternatives, the purpose is unambiguous.

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

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

The description implies usage when a GitHub URL is provided, but it does not explicitly state when to use it versus alternatives, nor does it mention any exclusions or prerequisites. It is minimal guidance, relying on the tool name and context. There is no explicit 'use this when...' or 'do not use when...'.

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

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

No annotations are provided, so the description carries full responsibility. It only mentions 'Titles discarded,' implying output is a count, but does not disclose that the nine input parameters are largely irrelevant to the core function (many are explicitly 'discarded'). It also omits any side effects, rate limits, or error behavior. The parameter disposal is a behavioral trait that is left unexplained.

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

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

The description is two short sentences with no fluff. The core action is front-loaded, and the additional note about titles is concise. It is appropriately sized for a simple tool, though it could benefit from a bit more context without losing conciseness.

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

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

The tool has nine parameters (all optional) and no output schema. The description does not explain why these parameters exist, what the count represents, how to interpret the result, or any limitations. It also does not clarify that the parameters are shape-check placeholders, which is a significant gap for a tool with such a large schema. The description is too minimal to be fully usable.

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's description already explains its own role (e.g., 'Git ref name; discarded after the shape check'). The tool description adds no extra meaning about parameters beyond the schema. Given the high coverage, 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 action: 'Count current Hacker News front-page stories.' This is a specific verb+resource. It does not explicitly differentiate from sibling tools, but the purpose is unique enough to stand alone. The 'Titles discarded' hint adds minor clarity about output scope.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, edge cases, or when to prefer a sibling tool. The description gives no context for selecting this over, say, web-fetch or fetch-status.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It provides no information about side effects, return values, read-only nature, or error behavior. The tool appears to be a static reference, but the description does not even confirm that, leaving the agent completely in the dark about how it behaves.

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, so it is concise and front-loaded. However, it is under-specified and does not earn its place because it provides minimal information. It is not verbose, but the lack of substance means it is not appropriately sized for the tool's complexity.

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

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

The tool has 9 parameters, no output schema, and no annotations. The description is extremely incomplete: it does not explain what the tool does, what it returns, when to use it, or how the parameters are used. An agent has insufficient information to invoke this tool correctly or even decide whether to use it.

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

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

Schema coverage is 100% (each parameter has a description), so the baseline is 3. However, the tool description does not add any meaning to the parameters, and the parameter set is highly heterogeneous (url, city, feed, host, json, path, query) with no explanation of how these relate to 'IANA timezone names'. The description fails to clarify the purpose of these parameters, making the tool confusing and reducing the value of the schema descriptions.

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

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

The description is a noun phrase ('Common IANA timezone names for clock calls') rather than a verb-based action. It does not state what the tool does (list, validate, return, etc.) and does not distinguish it from siblings like 'timezone' or 'utc-time'. The purpose is vague and requires inference.

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 phrase 'for clock calls' implies a context but provides no exclusions or comparison with sibling tools. An agent has no basis to choose this over 'timezone' or 'utc-time'.

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 states it fetches a public robots.txt and returns only group counts, which implies a read-only network operation, but it does not disclose any side effects, rate limits, error conditions, or whether authentication is needed. This is minimal disclosure for a tool with no annotation safety hints.

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

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

The description is a single concise sentence that gets to the point. However, it is almost too sparse, missing critical context, but for what it says, it is efficiently written and front-loaded.

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

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

For a tool with 9 parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain which parameters are required or how they relate to the tool's purpose, nor does it describe the return format or error handling. An agent would struggle to call this tool correctly.

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

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

The schema has 100% coverage, but the tool description does not map any of its parameters to the robots.txt fetch. The parameters include unrelated fields like city, json, zone, and query, and the description does not clarify which parameter (e.g., url or host) specifies the target robots.txt. This leaves the agent uncertain about how to invoke the tool correctly.

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

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

The description clearly states the tool fetches a public robots.txt and returns group counts, which is a specific verb and resource. However, it does not distinguish it from sibling tools like web-fetch or fetch-status, so it is clear but lacks differentiation.

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 exclusions or alternative tools, so the agent has no context for selecting 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?

Annotations are absent, so the description carries the full burden of behavioral disclosure. It only states 'Key discarded,' which hints at a side-effect-free validation, but does not clarify that the tool accepts a wide variety of unrelated inputs and discards them all, nor does it disclose the return format or any side effects for the other 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 concise—two short sentences—and front-loads the primary action. However, the brevity sacrifices necessary detail, making it under-specified rather than appropriately concise. It earns a mid-score for being terse but fails to deliver substantive content.

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

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

With 9 parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain what a valid Jira key shape is, how to invoke the tool with the given parameters, or what the result looks like. The description's focus on 'key' conflicts with the schema's generic fields, leaving the agent without sufficient context to use the tool correctly.

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

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

Schema description coverage is 100%, and each parameter already has a descriptive explanation (e.g., 'Git ref name; discarded after the shape check'). The tool description adds no additional parameter context beyond the schema. Per the rubric, a baseline of 3 is appropriate when the schema is fully documented.

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

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

The description states a specific verb and resource ('Check a Jira issue key shape'), but the input schema contains nine parameters (ref, url, city, feed, host, json, path, zone, query) with none explicitly labeled as a Jira key. This mismatch makes the purpose ambiguous and fails to distinguish the tool from sibling shape-checkers like domain-shape or github-repo-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?

No guidance is provided on when to use this tool versus alternatives. There is no mention of conditions, exclusions, or sibling tools. The description only repeats the core action without contextual cues for an agent to decide between this and similar shape validators.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. The only behavioral hint is 'Body discarded,' which implies the tool returns status but not the body. However, it omits critical behavior like whether network access is involved, any side effects, rate limits, or how it handles the varied parameters. For a tool that likely performs HTTP requests, this is insufficient.

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

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

The description is concise (two sentences) and front-loads the primary action. However, it is too sparse to convey the tool's actual scope, making it under-specified rather than appropriately sized. It doesn't waste words, but it lacks necessary content.

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

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

For a tool with 9 parameters, no output schema, and no annotations, the description is woefully incomplete. It fails to explain how the parameters relate to the stated purpose, what the return value looks like beyond 'HTTP status', or how the tool behaves with each parameter type. An agent would be unable to use this tool correctly without additional information.

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

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

The schema descriptions cover 100% of parameters and each has a descriptive note (e.g., 'discarded after the shape check', 'no disk access'). The description adds no parameter information, but since the schema already documents them, a baseline score of 3 is appropriate.

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

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

The description states a specific function ('HTTP status for a public library docs URL') but it only covers one use case while the schema accepts 9 unrelated parameters (city, json, path, zone, query). This makes the actual scope misleading and fails to distinguish it from siblings like fetch-status or normalize-url, which also deal with URLs and status.

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

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

No guidance is given on when to use this tool versus alternatives such as fetch-status, browser-url-ok, or normalize-url. There is no mention of conditions, exclusions, or contexts that would help an agent choose this tool.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The only behavioral detail is 'Values discarded', which hints at output behavior but says nothing about side effects, error handling, or whether the operation is read-only. It does not explain what happens with invalid JSON or missing parameters.

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

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

The description is a single short sentence, which is concise and front-loaded. It avoids fluff and waste. However, it is so brief that it sacrifices necessary detail, but conciseness itself is strong.

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

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

With 9 optional parameters and no output schema, the description is woefully incomplete. It does not explain which parameter is the JSON object, how multiple parameters are handled, what the return value looks like, or any error conditions. An agent cannot reliably call this tool without further clarification.

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

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

Schema coverage is 100%, so each parameter has a description, but the tool description fails to connect the purpose to any specific parameter. The 'json' parameter is described as 'JSON text to validate; discarded after the check', which conflicts with the tool's stated purpose of counting keys. The description adds no value beyond the schema and even misleads about the parameter's 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 states a clear verb+resource ('Count keys in a JSON object'), but it does not clarify how the JSON object is provided. The schema has 9 optional parameters, and only 'json' could plausibly be the input, yet its schema description says 'JSON text to validate; discarded after the check' rather than 'count keys'. This ambiguity makes it hard for an agent to know what to pass, and it does not differentiate from siblings like validate-json or status-catalog.

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 prerequisites, edge cases, or when not to use it. An agent has no indication of the tool's intended role among the many sibling utilities.

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 reveal that query and fragment are dropped, which is valuable, but it does not mention error handling, output format, or that only HTTPS URLs are accepted (per the schema). The description is accurate but incomplete for a tool with no annotation support.

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

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

The description is a single sentence that front-loads the core purpose and adds a behavioral note about dropping query and fragment. It is concise with zero wasted words, making it easy for an agent to quickly grasp the function.

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

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

The description is incomplete for a tool with 9 schema parameters, none required. It only addresses the 'url' parameter, leaving the purpose of parameters like 'city', 'feed', 'json', etc. unexplained. Additionally, there is no output schema, so the return format (e.g., object, tuple) is unspecified. The agent cannot fully understand how to call this tool correctly or what it returns beyond the stated components.

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

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

The schema descriptions cover all 9 parameters (100% coverage), so the schema already documents each parameter. The tool description does not add meaning beyond the schema; it only references the 'url' parameter implicitly. Since the schema provides full descriptions, 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 tool's function: returning origin, host, and path for a URL, and explicitly notes that query and fragment are dropped. This is a specific verb+resource statement that distinguishes it from sibling URL tools like browser-url-ok or fetch-status, which likely fetch or check 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?

The description provides no guidance on when to use this tool versus alternatives such as browser-url-ok or fetch-status. It does not state prerequisites, typical use cases, or conditions that would make it preferable over sibling tools. The context is implied but not explicit.

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

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

The description discloses that no browser is launched, a useful trait, but it does not explain what actually happens: whether it performs an HTTP request, validates URL format, or checks DNS. It also omits details on network access, timeouts, or what 'opened' means. Parameter descriptions further obscure behavior, e.g., 'path' says 'File path to check; no disk access,' which is contradictory.

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 omits critical information about how to use the tool, which parameters matter, and what the result looks like. Conciseness without completeness is under-specification, not efficiency; the sentence fails to earn its place by providing actionable guidance.

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

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

With nine parameters, none required, no output schema, and no annotations, the description must explain what the tool does and what to pass. It does not. It fails to specify which parameters are relevant for a URL check, the expected input format, or what the output indicates. This is completely inadequate for an agent to invoke the tool correctly.

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

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

All nine parameters have descriptions (100% schema coverage), but the descriptions are largely irrelevant or misleading. For instance, 'ref' is 'Git ref name; discarded after the shape check' and 'city' is 'City name for a public weather hint' – neither relates to checking a URL. These descriptions actively mislead an agent about which parameters to use and what they do, providing no useful 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 clear intent: 'Check whether a URL can be opened.' However, the input schema introduces nine unrelated parameters (e.g., 'city', 'zone', 'query') with descriptions like 'City name for a public weather hint,' which conflict with the stated purpose and confuse the resource being operated on. The name 'playwright-url-ok' implies browser automation, yet the description says 'No browser is launched,' adding further ambiguity about the tool's actual role.

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

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

No guidance is provided on when to use this tool instead of siblings like 'browser-url-ok' or 'normalize-url'. The only hint is 'No browser is launched,' which might imply a lighter check, but there is no explicit mention of alternatives, prerequisites, or conditions that would select this tool.

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

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

With no annotations, the description carries the full burden. It discloses that the query is discarded, which is useful, but it remains silent on the fate and handling of the other 8 parameters. The schema descriptions mention some discard behavior, but the tool description does not synthesize that. It also does not state the return value or any side effects, leaving major 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 extremely concise (two short sentences), which is good for front-loading the core action. However, it is under-specified, omitting crucial information about the tool's broader behavior. Conciseness is not the same as completeness; this leans toward oversimplification.

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 annotations, and no output schema, the description is far from complete. It only covers the query parameter, leaving the purpose and handling of the other parameters unexplained. An agent would need to inspect the schema to understand the tool's full capabilities, which the description should have summarized.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds minimal value beyond the schema, only referencing the query parameter. It does not mislead, but it fails to highlight that other parameters are also validated or discarded. Since the schema already documents each parameter, the description does not need to repeat, but it could have added context on how parameters interrelate.

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

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

The description states a clear verb and resource: 'Count characters in a search query.' This is specific and aligns with the tool name. However, it does not explain the other 8 parameters in the schema, so the full scope of the tool is unclear. It partially distinguishes from siblings like memory-key-count by focusing on search queries, but lacks explicit differentiation.

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. There is no mention of context, prerequisites, or exclusions. An agent has no clue whether this tool is preferred over shape-checking siblings or when to pick 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 carries the full burden of behavioral disclosure. It only says 'catalog' and does not disclose that parameters appear to be discarded (as implied by schema descriptions like 'discarded after the shape check'), what the output format is, or whether the tool has side effects. The description leaves the tool's behavior opaque.

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

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

The description is a single, efficient sentence that clearly front-loads the tool's core purpose. It is appropriately concise for a reference catalog, though it omits detail that might be needed for such a parameter-heavy tool. No waste, but under-specification prevents a 5.

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

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

The tool has 9 parameters, no output schema, and no annotations. The description only states the catalog purpose, failing to explain what parameters do, what the return value looks like, or how the tool should be invoked. An agent cannot determine what to pass or what to expect, making the description incomplete for effective use.

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 nine parameters have descriptions, meeting the baseline. However, the tool description adds no parameter meaning; it doesn't connect the parameters (ref, url, city, etc.) to the HTTP status catalog, leaving an agent unclear on which, if any, to supply. The schema descriptions themselves are detailed but unrelated to the catalog's purpose.

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

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

The description states a clear, specific purpose: a short catalog of common HTTP status codes. It distinguishes itself from sibling tools like fetch-status or browser-url-ok, which likely fetch live statuses, whereas this is a static reference catalog.

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 doesn't mention whether to use it for reference, learning, or debugging, nor does it exclude live status checking. An agent must infer the intended context from the purpose alone.

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

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

With no annotations, the description must disclose behavior itself. It mentions 'Prompt discarded', which indicates input is ignored, but it does not disclose whether the operation is safe/read-only, any side effects, or what the template actually is. This is minimal disclosure for a tool that likely just returns a fixed output.

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 with no filler, making it efficient. However, it is under-specified, which is a trade-off, but conciseness itself is strong.

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

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

Despite having 9 parameters and no output schema, the description provides no detail on the template content, return value, or usage context. An agent would not know what the template looks like or when to invoke this tool, making it incomplete for effective selection.

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 description coverage is 100%, with each parameter explicitly stating it is discarded after a check. The description adds only a generic 'Prompt discarded' which does not enhance parameter understanding beyond the schema. Baseline 3 applies.

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

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

The description states the tool 'Return a three-step thinking template', which is a clear verb+resource. However, it does not explain what the template contains or how it differs from sibling tools like 'calc-eval' or 'validate-json', so it lacks sibling differentiation.

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 scenarios where it is appropriate, leaving the agent to infer its purpose.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the purpose and does not mention output format, error handling, or the fact that many input parameters (e.g., ref, url, city) are discarded. The presence of 9 parameters, most unrelated to timezone, is unexplained and could confuse an agent. The description adds no behavioral context beyond the basic function.

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

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

The description is a single sentence with no wasted words. It is front-loaded with the core function. It is appropriately concise, though it could benefit from additional context without becoming verbose.

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

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

The tool is simple in purpose but the description omits critical details: it does not specify that only 'zone' is used, it does not describe the return format, and it does not address the unrelated parameters. With no output schema and no annotations, the agent is left guessing about expected inputs and outputs. This is insufficient for a tool with a complex, multi-parameter schema.

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

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

Schema description coverage is 100%, so each parameter is documented in the schema. The tool description adds no parameter-specific information. However, the schema itself describes most parameters as 'discarded,' which provides clarity that only 'zone' is relevant. Since the schema already covers semantics, the description meets the baseline of 3.

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 time in a named IANA timezone' clearly states the function: it returns the current time for a specific timezone. The resource is precise, and it distinguishes itself from siblings like 'utc-time' (which gives UTC) and 'iana-zones' (which lists zones). 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 when a specific IANA timezone's current time is needed, but it does not explicitly mention alternatives or when not to use it. Sibling names suggest context, but the description provides no explicit routing guidance. This is adequate but not explicit.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states the core action and does not reveal that the nine parameters are optional and discarded, that the operation is read-only, or any details about the return format (e.g., ISO string, epoch). This leaves the agent without crucial behavioral context.

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

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

The description is a single, focused sentence with no redundancy. It is maximally concise and front-loaded, containing exactly the essential information about the tool's purpose without any wasted language.

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

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

Despite having 9 optional parameters and no output schema, the description does not explain how these parameters relate to the returned timestamp or what the return value looks like. The schema hints that parameters are discarded, but the description fails to tie this together, leaving the agent uncertain about correct invocation and result interpretation.

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 clear descriptions for all 9 parameters (e.g., 'discarded after the shape check'), so the schema already handles parameter meaning. The tool description adds no extra parameter semantics, making the baseline of 3 appropriate. The description's silence on why parameters exist is a completeness issue, not a semantics one.

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' uses a specific verb ('Current') and resource ('UTC timestamp'), clearly identifying the tool's function. It is distinct from sibling tools like 'timezone' and 'iana-zones' in that it returns the current time rather than timezone metadata, though it does not explicitly differentiate itself.

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 lacks any mention of conditions, prerequisites, or exclusions, leaving the agent to infer usage solely from the name. This is a significant gap for a tool with many siblings.

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

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

With no annotations, the description must carry behavioral disclosure. It states 'The body is discarded,' which is a useful behavioral trait (no persistence). However, it does not disclose return values, error handling, network activity, or side effects. The tool might accept multiple inputs (url, json, etc.), but the description only references 'body' without clarifying which parameter that is, leaving behavioral ambiguity.

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

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

The description is extremely concise—two sentences—and front-loads the core purpose. Every word earns its place, and it avoids redundant information. It is appropriately sized for a simple validation tool, though it could optionally add a brief example or clarify parameter mapping without becoming verbose.

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

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

Despite the tool's simplicity, it has 9 parameters and no output schema. The description does not explain how these parameters are used or which one constitutes the 'body.' It does not describe the return format (e.g., boolean or error), nor does it clarify the relationship between parameters like 'url' and 'json.' This is a significant gap for an agent deciding how to invoke the tool correctly, especially with multiple possible input sources.

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 detailed descriptions for all 9 parameters, so the baseline is 3. The tool description adds no parameter-specific meaning beyond the schema, and it does not explain how parameters like 'json' or 'url' relate to the 'body' mentioned in the description. The schema already does the heavy lifting, so the description offers 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 clearly states the tool's function: 'Check whether a body is valid JSON.' It uses a specific verb and resource, and the name 'validate-json' reinforces the purpose. It distinguishes itself from sibling shape-check tools (domain-shape, github-repo-shape, etc.) by focusing specifically on JSON validation, leaving no ambiguity about what it 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?

The description implies the use case (validate JSON) but does not explicitly mention when to use this tool versus alternatives like domain-shape or jira-key-shape. There is no guidance on when not to use it or which sibling to choose based on format. The name and description make the primary purpose obvious, but explicit routing to alternatives is absent.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says it returns current temperature via Open-Meteo, but fails to disclose that most of the 9 input parameters are discarded (as indicated by schema descriptions) and that only 'city' is relevant. It also doesn't mention whether this is a real API call, a cached hint, or a stub, nor any side effects or rate limits. The word 'hint' suggests a lightweight response, but that is not clarified.

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, which is efficient in structure. However, it is under-specified to the point of being terse, omitting essential context about parameter usage and behavioral details. While it is concise, it does not earn its brevity by covering the necessary information; it sacrifices completeness for brevity.

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

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

Given the tool has 9 parameters and a simple weather purpose, the description is incomplete. It does not clarify which parameter to use, that all others are ignored, or what the output format looks like (no output schema). For a tool that appears to be a simple temperature check, the description should at least mention that only the 'city' parameter matters and what the return value is. This is a significant gap.

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

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

The schema has 100% description coverage, with each parameter documented, including notes that many are 'discarded'. The tool description adds the explicit connection between the city parameter and the weather lookup, which is useful. However, it does not add significant meaning beyond the schema, such as the format for the city name or how the temperature is returned. The description adds minimal value over the schema's own descriptions.

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

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

The description clearly states the function: retrieving current temperature for a city via Open-Meteo. It uses a specific verb ('current temperature') and identifies the resource (city) and service. It distinguishes from siblings implicitly by naming the weather domain, though it doesn't explicitly contrast with any other 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 alternatives. It does not mention that it's a lightweight 'hint' (as opposed to a full weather service), nor does it state any prerequisites or exclusions. The description leaves the agent to infer that it is for current temperature checks, but gives no context on when not to use it.

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

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

No annotations are present, so the description must carry the full behavioral disclosure. It notes that the body is discarded, but it does not describe behavior for the other parameters, whether the operation is read-only, error handling, or any side effects. The coverage is incomplete relative to the tool's apparent multi-purpose nature.

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

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

The description is very short and front-loads the primary action, which is efficient. However, the structure does not accommodate the tool's multi-purpose design; it is concise but under-specified, trading completeness for brevity.

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

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

With nine parameters, no output schema, and no annotations, the description is grossly inadequate. It explains only the URL-checking behavior and provides no information about the purpose or behavior of the other eight parameters. An agent cannot correctly invoke this tool for any of the other parameter types, making the description nearly useless for full utilization.

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

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

Schema coverage is 100% with individual parameter descriptions, so the baseline is 3. However, the tool description omits all parameters except the URL-related ones, and even that is implied rather than explicit. This creates a mismatch between the description and the schema's breadth, potentially misleading an agent into thinking only the 'url' parameter matters. The description adds no value beyond the schema and actually contradicts it.

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

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

The description states a clear action: retrieving HTTP status and content type for a public URL. However, the input schema lists nine parameters, many of which (ref, city, feed, json, path, zone, query) are unrelated to this purpose, indicating the tool actually serves multiple distinct validation functions. The description only covers a subset, leaving the overall purpose ambiguous.

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

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

No guidance is provided on when to use this tool versus sibling tools such as fetch-status, normalize-url, or browser-url-ok. The description does not mention alternatives, exclusions, or conditions, forcing the agent to rely on the tool name and schema alone.

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

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

No annotations are provided, so the description must fully disclose behavior. It only states that the 'Title discarded after the call', implying no persistent side effects, but does not clarify whether the check involves network access, what happens on invalid titles, or any other behavioral details. The description is too sparse to convey the tool's operation.

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

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

The description is extremely concise—two short sentences with no fluff. It front-loads the primary action ('Check whether a Wikipedia title exists') and then adds a note about discarding. For its length, it is well-structured, but the brevity comes at the cost of substance.

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

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

With 9 parameters, no required fields, and no output schema, the description is far from complete. It does not explain how the parameters are used, what the tool returns (e.g., boolean, status), or any edge cases. An agent cannot confidently call this tool correctly based on the description alone. The mismatch between the description and schema compounds the incompleteness.

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

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

Schema coverage is 100%, so the schema documents each parameter. However, the description adds no meaning to the parameters—it does not explain how 'ref', 'url', 'city', etc. relate to checking a Wikipedia title. In fact, the description mentions a 'title' that does not appear in the schema, misleading the agent about the expected input. The description fails to bridge the gap between the schema and the stated purpose.

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

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

The description states a specific action: check whether a Wikipedia title exists. However, the input schema does not contain a 'title' parameter, and the parameters listed (ref, url, city, etc.) are unrelated to Wikipedia titles. This mismatch makes the purpose confusing and does not clearly differentiate from sibling tools that also perform checks (e.g., browser-url-ok, domain-shape). The action is clear in isolation but not aligned with the schema.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention any conditions, exclusions, or alternative tools. An agent would have no basis for selecting this over sibling tools like wiki-title-check or domain-shape.

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