Language sn

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

No annotations are provided, so the description carries the behavioral burden. It discloses that task text is discarded and that the result is connection methods, which implies a read-only indexing operation, but it does not address whether invoking the tool has costs, auth requirements, rate limiting, or whether any network request is actually made. This leaves meaningful gaps for a 'pay-per-call' 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 compact and front-loaded with the main purpose. Each sentence earns its place: one defines the operation, one states the output, and one warns about discarded task text. There is no wordy or redundant material.

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 names the output type ('connection methods') but there is no output schema, and the tool has 9 optional parameters and no required ones. It does not explain the return shape, whether multiple methods can be returned, or how a caller should choose among parameters. The individual parameter descriptions cover inputs well, so the main missing context is on the return side and call selection 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%, so the individual parameters already carry useful semantics. The description adds the general frame that the inputs are task hints and that text is discarded, but it does not map specific task examples to the parameter names or clarify whether any particular parameter must be provided. This is adequate but not an improvement over the schema.

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

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

The description clearly states a specific action and resource: 'Find a public pay-per-call tool gateway'. It gives concrete task examples (weather, search, scrape, voice) and clarifies the result ('Returns connection methods'), which distinguishes it from the many sibling checker/hint tools.

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

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

The description gives clear context for when the tool is appropriate by naming what it is for, and the phrase 'Task text discarded' is a useful warning not to pass natural-language task prose. It does not explicitly name alternatives or exclusions, but the use case is clearly implied rather than merely vague.

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 explicitly states that no browser is launched, but fails to say whether the tool makes a network request, accesses the file system, returns diagnostic info, or has side effects. Nested schema hints like 'no disk access' and 'discarded after' appear in parameter descriptions, but these aren't surfaced in the tool description and don't clarify the tool's overall 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?

Two short sentences with the purpose stated first, followed by a useful caveat: 'No browser is launched.' No filler words, every sentence earns its place, and the core idea is 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?

This is a 9-parameter, optional input check tool with no output schema and no annotations. The description doesn't explain what the tool returns, what a 'can be opened' verdict looks like, or how to interpret the check, nor does it reconcile the presence of unrelated_parameters. The description is under-specified for an agent to call it confidently.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds no parameter-level meaning; it just states the overall purpose. The individual parameter descriptions are already present and adequate, so the tool description doesn't need to compensate, but it also provides no extra clarity on why many seemingly unrelated params (city, zone, json, feed) are accepted for a URL check.

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 action 'Check whether a URL can be opened' with a specific resource (a URL) and a distinguishing behavioral note that no browser is launched. It doesn't name sibling tools, leaving some ambiguity about what 'can be opened' means versus fetch-status or normalize-url, but the core purpose is specific and not a tautology.

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 rather than the many siblings like playwright-url-ok, fetch-status, or normalize-url. 'No browser is launched' is a behavioral trait, not a usage condition. With 29 siblings and no exclusions or alternatives, the agent is left to infer appropriate usage.

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

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

No annotations are provided, so the description must fully disclose behavior. It only says 'Expression discarded' without explaining what happens to the actual parameters, side effects, required permissions, or output. The schema hints each parameter is discarded, but the description does not clarify the overall behavior, leaving the agent in the dark.

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

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

The description is extremely short, but it is under-specified rather than concise. It provides no useful information and fails to earn its place. A highly terse description with no substance scores low because it does not help the agent.

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

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

For a tool with 9 parameters, no annotations, and no output schema, the description is completely inadequate. An agent would have no idea what the tool does, when to call it, or what to pass. The description does not compensate for the lack of structured metadata.

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-level description adds nothing meaningful about how parameters relate to the purpose. The claimed arithmetic purpose doesn't map to any parameter, and the description fails to explain why these nine unrelated parameters exist or how they are used.

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

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

The description claims to 'Evaluate a+b style arithmetic' but the 9 input parameters (ref, url, city, feed, etc.) have nothing to do with arithmetic, and no expression parameter exists. This is misleading and does not state what the tool actually does with the provided inputs. It fails to distinguish itself from the 27 sibling tools.

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

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

No context is given for when to use this tool versus alternatives. There is no mention of intended scenarios, exclusions, or related tools. The description provides zero guidance on selection.

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

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

The description includes one useful behavioral guarantee: page content is not stored. However, it does not disclose network access, error behavior, response structure, or limits, and no annotations cover these aspects.

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

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

The description is two short, front-loaded sentences with no redundancy. The core output and a useful privacy-related behavior are stated directly.

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

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

The tool has 9 optional parameters in a single schema, yet the description only addresses the URL use case. It never explains how the other parameters interact, what happens with no arguments, or what the returning data looks like, leaving substantial ambiguity.

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 description only needs to add marginal value rather than carry parameter documentation. It helps by scoping the result to a URL, but the many unrelated optional parameters are not explained 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 concrete outcome: return host, scheme, and HTTP status for a URL, plus a clear note that page content is not stored. It is clear, but it does not explicitly differentiate this from related siblings such as 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 when-to-use or when-not-to-use guidance is provided, and no alternatives are named. Usage is only implied by 'for a URL', which is too weak given the many sibling tools that handle HTTP status and URL operations.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It only states 'No identifiers are retained', which is a data-retention note but does not reveal whether the tool performs network calls, side effects, or how it processes inputs. The schema hints at some behaviors (e.g., 'no disk access' for path), but the description itself is nearly silent on 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 only two sentences, which is concise, but it is under-specified rather than appropriately sized. The first sentence states a vague purpose, and the second is a privacy note. There is no structured information about inputs, outputs, or usage, so the brevity is a deficiency, not an asset.

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 diverse optional parameters and no output schema, the description should explain what the tool does with these inputs, what the classification returns, and how it relates to sibling tools. None of this is present. The description is fundamentally incomplete for an agent to use the tool correctly.

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

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

Schema description coverage is 100%, so each parameter is already documented with its own description. The tool description adds no additional parameter-level meaning, so it neither compensates nor detracts. Per baseline, a score of 3 is appropriate when the schema fully covers parameter semantics.

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

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

The description 'Show how this request is classified' is vague and does not specify what kind of classification, what the output represents, or which inputs are relevant. It does not clearly distinguish this tool from its many siblings, such as 'domain-shape' or 'validate-json'. The verb 'show' is generic and the noun 'classification' is undefined.

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

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

The description provides no guidance on when to use this tool versus its alternatives. There is no mention of use cases, prerequisites, or situations where a sibling tool would be more appropriate. An agent has no way to decide if this tool is the right one for a given request.

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

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

No annotations are provided, so the description is the full authority. It usefully states that WHOIS/ownership data is not included, which implies a local, safe operation. However, it does not describe what is returned, how invalid input is handled, or whether any network/disk access happens beyond the 'no WHOIS' implication.

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 compact and efficient, a single sentence that leads with the action and adds a meaningful negative boundary. There is no fluff or repetition.

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 creates a significant gap with the input schema: it mentions only 'hostname', while the schema contains nine parameters for different kinds of checks (file paths, refs, JSON, query length). No output schema and no explanation of the return value leaves the tool partially specified for an agent.

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

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

Schema description coverage is 100% and all parameters have individual descriptions, so the baseline is 3. The description adds no extra meaning about which parameter should be used or how the nine inputs relate to the 'split hostname' job, providing no extra guidance to the caller.

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

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

The description uses the verb 'split' a concrete resource ('hostname') and adds a valuable negative clarifier ('without WHOIS or ownership data'). It is clear enough to distinguish this from WHOIS-style lookups, but it doesn't explicitly contrast with sibling shape tools like github-repo-shape or jira-key-shape.

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

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

The description implies the use case—when an agent needs hostname labels without ownership data—but gives no alternatives, exclusions, or prerequisites. It clearly says what action it does but not why this tool over the other 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?

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It only mentions the URL case, but the schema includes eight other parameters (e.g., ref, city, json, zone) that are implied to be checked and discarded; the description does not surface this broader behavior. This makes the tool's actual operations unclear and potentially misleading, as an agent might assume it only accepts a URL.

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

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

The description is a single, front-loaded sentence that conveys the core action efficiently. It is concise and easily parsed, with no extraneous words. However, its brevity comes at the cost of omitting necessary context about the full input surface, which slightly offsets the structural quality.

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

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

The tool has nine optional parameters, no output schema, and is surrounded by many distinct siblings (web-fetch, normalize-url, browser-url-ok, etc.). The description is far too minimal to cover this complexity—it does not explain the purpose of non-URL parameters, the return format, or when to select it over alternatives. An agent cannot reliably determine how to invoke it correctly for anything beyond a simple URL check.

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

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

The input schema provides 100% coverage with a description for each of the nine parameters, so the baseline is 3. The tool description adds no additional semantics beyond what the schema already states; it merely highlights the URL as central but does not clarify the role of other parameters. It neither elevates nor degrades the schema-provided information.

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

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

The description clearly states a specific action ('HEAD a public URL') and the output ('status only'), which is unambiguous about the primary use. However, it does not differentiate from siblings like web-fetch or normalize-url, leaving some ambiguity about when this tool is preferred. The core purpose is clear for the URL case, though the schema implies a broader scope.

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

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

The description gives no guidance on when to use this tool versus alternatives such as web-fetch or playback-url-ok. There is no mention of scenarios where a HEAD request is advantageous, nor any exclusions or prerequisites. An agent would have to infer usage entirely from the name and the brief description, which is insufficient given the 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 carries the full behavioral disclosure burden, and the only behavioral clue is the cryptic "Path discarded." It does not say whether the tool performs network access, validates output, mutates state, or what it returns, leaving material behavior undisclosed.

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

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

The text is extremely terse and free of filler, which makes it superficially concise. However, "Path discarded" is cryptic and the wording is so thin that it becomes under-specification rather than well-crafted conciseness.

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

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

For a tool with nine unrelated parameters, no output schema, and no annotations, the description is far too sparse to let an agent invoke it correctly. It omits return values, error scenarios, network behavior, and which parameters are relevant for a Figma URL parse, making the documentation contextually 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% for all nine parameters, so the baseline is adequate. The description's reference to a Figma file URL loosely clarifies the intended `url` type but does not explain the odd other parameters such as `city`, `feed`, `json`, or `zone`, nor does it map the claim about discarded paths to named parameters.

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

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

"Parse a Figma file URL" is a specific verb+resource that immediately identifies the tool's domain and distinguishes it from generic URL tools like normalize-url. The added "Path discarded" gives a useful behavior hint, though it stops short of explicitly contrasting with sibling shape tools like 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?

There is no guidance on when to use this tool versus alternatives such as playwright-url-ok, browser-url-ok, or normalize-url. The description implies it is for parsing Figma URLs, but it never states when-not-to-use it, prerequisites, or selection criteria.

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

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

With no annotations provided, the description must carry the safety disclosure, and it does so by explicitly stating "No disk access." That is a key behavioral guarantee for an agent deciding whether to invoke it. It still omits return/error semantics, so it is not fully transparent, but the most important side-effect constraint is stated.

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

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

Two very short sentences, with the core purpose front-loaded and the no-disk-access caveat immediately after. Every word adds the value value and there is no padding.

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 simple validator, the core context is covered. However, with no output schema, no annotations, and nine optional parameters, the description is thin: it does not say what a caller should expect as a return, whether an invalid path errors or returns false, or how the unrelated parameters are intended to be used.

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 parameters are already documented. The description adds the high-level intent that a path is being checked but does not explain how the many optional parameters relate to the check. This is the baseline for schema already doing the work.

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 whether a path looks safe" — and adds a meaningful qualifier, "No disk access." This is enough to mark it as a lexical path validator and separates it from sibling fetch/shape tools, though it does not explicitly name the sibling it is 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?

The intended use is implied: call it to perform a lightweight, disk-free path sanity check. However, there is no explicit statement of when to use it versus alternatives, no prerequisites, and no when-not-to-use guidance beyond the implication that it does not verify real filesystem state.

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

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

With no annotations, the description must carry the full behavioral burden. It does not disclose that the tool makes an external network call to Open-Meteo, what it returns (beyond lat/long), whether it is read-only, or that many parameters are discarded as described in the schema. The description also contradicts the schema descriptions for 'city' (which says 'for a public weather hint,' not geocoding). No behavioral details are provided.

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

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

The description is one short sentence, which is concise but under-specifies. It lacks front-loaded critical details such as how to specify a place or what response format to expect. The brevity does not compensate for the missing guidance given the tool's complexity.

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

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

For a tool with 9 optional parameters and no output schema or annotations, this description is severely incomplete. It does not explain the diverse schemas, which parameters are required for geocoding, or what the output looks like. An agent would be unable to safely or correctly invoke this tool.

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

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

The schema has 100% coverage, so each parameter has a terse description, but these descriptions are often inconsistent with the tool's stated purpose (e.g., 'json' is for validation, 'path' for file check, none relevant to lat/long). The overall description adds no explanation of which parameters are meaningful for geocoding or how they interact. An agent cannot determine which of the 9 optional parameters to provide.

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 output (latitude and longitude for a place via Open-Meteo), which gives a clear resource and verb. However, the input schema lists 9 diverse parameters (ref, url, json, path, etc.) that have no obvious connection to geocoding, so an agent cannot determine how to invoke the tool to actually get coordinates. The purpose is clear in isolation but not in the context of 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?

No guidance is provided on when to use this tool versus siblings like weather-hint or timezone. There is no mention of prerequisites, alternatives, or exclusions. The description gives no contextual hints about when geocoding is needed versus other operations.

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 behavioral disclosure burden. It implies a pure parse operation but does not state whether the tool performs any network access, how invalid URLs are handled, or what happens when the url parameter is omitted.

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?

One direct sentence with no filler. The main action and input are front-loaded, making the description easy to absorb.

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 9-parameter tool with no output schema and no annotations, a single sentence is under-specified. It leaves the return shape, invalid-input behavior, and exact parameter expectations unclear, so the agent would still need additional inference to call the tool correctly.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds the GitHub-specific owner/repo intent and the URL as input, but it does not help an agent choose among the many optional parameters or clarify the role of the 8 non-URL parameters.

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

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

The description uses a specific verb and target: parse owner and repo from a GitHub URL. This clearly states the tool's resource and output while distinguishing it from sibling shape tools like jira-key-shape or figma-url-shape.

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

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

The only usage cue is the phrase 'GitHub URL', which implies when to use the tool. However, there is no explicit guidance about when not to use it or which sibling tool to prefer for non-GitHub URL shapes.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only mentions that 'Titles discarded', which hints at some processing, but does not explain how parameters affect the behavior, whether the tool makes network calls, or what side effects exist. It is not misleading, but it is severely under-transparent.

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

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

The description is one short sentence that leads with the main action and includes the only behavioral note ('Titles discarded'). It is efficient with words and quickly conveys the core purpose. However, it is so terse that it omits important context, so it does not earn a 5, but it is still well-structured 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?

Given the tool has nine optional parameters and no output schema, an agent cannot determine how to invoke this tool correctly. The description does not explain which (if any) parameters are relevant, what the expected return value is, or how the count is obtained. It is incomplete for anything beyond the most trivial call with no arguments.

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

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

The input schema already provides descriptions for all nine parameters (100% coverage), each stating that the value is 'discarded' after some check. The description text adds no additional meaning about how any parameter relates to the count operation. Per the calibration, with high schema coverage, a baseline of 3 is appropriate, and the description does not elevate 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 clearly states a specific action ('Count') and a specific resource ('current Hacker News front-page stories'). It also adds a useful detail ('Titles discarded') that clarifies what is not returned. This effectively distinguishes it from sibling tools like web-fetch or browser-url-ok, which are about fetching/checking, not counting.

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, nor any mention of prerequisites, exclusions, or context that would help an agent decide. The description only states what it does, not when to use it. This is a clear 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses almost nothing: no side effects, read-only status, error behavior, or what the tool returns. The schema even mentions several parameters that are 'discarded', but the description never explains how the tool actually behaves at runtime.

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

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

The description is a single short sentence with zero filler, and the central resource ('IANA timezone names') is front-loaded. It is efficiently written, though 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 nine parameters, no output schema, no annotations, and ambiguous relationship to `timezone`/`utc-time`, the description is severely under-specified. It does not explain return values, which parameters actually impact the call, or why the other eight parameters exist — leaving the agent unable to correctly compose or interpret a call.

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 for this dimension is 3 even though the description adds no parameter-level detail. The tool's nine parameters are mostly documented as ignored or 'discarded', which is confusing given the zone-focus of description, but the schema carries the burden for parameter meaning.

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

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

The description names the resource ('IANA timezone names') and hints at the context ('clock calls'), but lacks a verb — it never states what invoking the tool actually does (return a list? validate a zone? resolve to UTC?). It gestures at the `timezone`/`utc-time` siblings but does not clearly distinguish itself from them, so an agent is left inferring the operation.

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

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

There is no guidance on when to use this tool versus the siblings `timezone` or `utc-time`, and no exclusions or alternative routing. The phrase 'for clock calls' implies some time-related usage, but nothing explicitly tells an agent when to pick this tool over its neighbors.

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

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

With no annotations, the description must carry the behavioral burden. It discloses that only group counts are returned (not full content), which is useful. However, it does not mention response format, error handling, or side effects (e.g., no disk access, rate limits), leaving many behaviors unspecified.

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

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

The description is a single, front-loaded sentence with zero filler. It states the action and the output scope immediately, making it easy to parse. Concise without being under-specified for its 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 a 9-parameter schema, the description does not connect any parameter to the actual operation. It omits which input (e.g., url) is needed to fetch a robots.txt and disregards the many 'discarded after' parameters, creating confusion. The output is vaguely described as 'group counts only' without structure. Given the schema's breadth, a richer description is required to guide correct invocation.

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

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

Schema descriptions cover 100% of parameters, so the baseline is 3. The description adds no parameter-specific information beyond the schema, relying entirely on the schema's per-param details. It does not clarify which parameter (e.g., url vs host) is required for the robots.txt fetch, so it adds no incremental 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 a specific action: fetch a public robots.txt and return group counts. The verb 'fetch' and resource 'robots.txt' are unambiguous, and the scope ('group counts only') is explicit. However, it does not differentiate from sibling tools like web-fetch or fetch-status that could also fetch URLs, so it lacks explicit sibling separation.

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 prerequisites, scenarios, or exclusions, nor does it reference sibling tools like web-fetch or normalize-url. An agent would have to infer usage from the name alone.

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

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

The description discloses that the key is discarded, and each parameter description repeats 'discarded after the check/call', indicating no side effects. However, it does not disclose what constitutes a valid shape, what the return value is (boolean, error message, etc.), or how non-Jira inputs are handled. Without annotations, the description carries the burden but only partially addresses it.

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

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

The description is extremely concise (two sentences), which is structurally efficient, but it is under-specified for a tool with nine parameters. The brevity does not compensate for the lack of essential information about scope and behavior.

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

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

With nine parameters, no output schema, and no annotations, the description is severely inadequate. It does not explain what shapes are validated, how the tool handles different input types, what it returns, or how it differs from siblings. An agent cannot safely call this tool without further information.

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

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

Schema coverage is 100%, so the baseline is 3, but the parameter descriptions are inconsistent with the tool's stated purpose—for example, 'url' is described as 'HTTPS URL to normalize or cite' rather than a Jira key shape check. The descriptions add no meaning about what 'shape' means for each param and are confusingly copied from other contexts. The tool description itself adds nothing to clarify the params.

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) that are unrelated to Jira keys, with descriptions referencing URL normalization, weather hints, and JSON validation. This mismatch makes the purpose misleading—an agent would not know what the tool actually checks or how to select it among sibling shape tools 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?

There is no guidance on when to use this tool versus alternatives. The description does not mention that it accepts various input types or that it might be a generic shape checker. An agent cannot infer when to prefer jira-key-shape over sibling tools like domain-shape or validate-json.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description says nothing about side effects, access patterns, output, or constraints. It offers a bare identifier, giving the agent no behavioral information.

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 under-specified, not concise. The single phrase 'ISO 639 language tag sn.' is a fragment that omits a verb and any contextual structure; it looks like a truncated thought rather than a deliberate, minimal summary.

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

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

With nine parameters, no output schema, no annotations, and no usage hints, the description is far from complete. The tool could be anything from a simple format validator to a network-aware checker, and the agent has no basis for a correct invocation.

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

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

Schema description coverage is 100% and each parameter has a descriptive string, so the baseline is 3. However, the tool description does not clarify which of the nine parameters are relevant to a language-tag check; the schema descriptions are generic and do not compensate for the absence of tool-level direction.

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 'ISO 639 language tag sn' names a standard and a tag but does not state what the tool does. It reads more like a label than a description; it cannot be distinguished from a validator, a lookup, or a formatter without guessing.

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 indication of when to use this tool rather than a sibling. No mention of alternatives, conditions, or exclusions. An agent gets no help in selecting it over similar shape-checking tools.

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

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

With no annotations, the description carries full behavioral burden. It discloses 'Body discarded', which is a useful behavioral detail, but it does not explain that the tool appears to handle multiple input types (city, zone, json) or what happens with those inputs. No mention of network behavior, error handling, or return format beyond HTTP status.

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 (one sentence) and front-loaded with the core action. However, it is under-specified relative to the tool's apparent multi-parameter nature, so brevity here comes at the cost of clarity. It is not verbose, but it trades 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 9 parameters, none required, and no output schema, the description is vastly incomplete. It only addresses URL-related behavior while ignoring the other 8 parameters. An agent cannot determine what the tool does with 'city', 'zone', 'json', etc., or when to invoke it. This is a severe gap for a complex tool.

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

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

Schema coverage is 100%, so each parameter already has a description. The tool description adds no extra meaning for any parameter; it only mentions 'URL' generically, while the schema covers all nine parameters. Baseline 3 is appropriate since schema handles parameter semantics adequately.

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: fetching HTTP status for a public library docs URL. However, the parameter list includes unrelated fields (city, zone, json, query), suggesting the tool is actually a multi-purpose checker, so the stated purpose is incomplete and potentially misleading. It is not a tautology, but it fails to convey the full scope of the tool.

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

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

There is no guidance on when to use this tool versus its many siblings (e.g., fetch-status, browser-url-ok, normalize-url). The description gives no context for selecting this tool over alternatives, and no exclusions or conditions are provided.

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

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

With no annotations at all, the description carries the full burden of behavioral disclosure. It offers 'Values discarded' as a behavioral trait, and the schema repeats 'discarded' notes for many parameters, but it never explains what happens with the JSON object's structure, how the result is returned, error behavior, or why a JSON 'count' tool would even accept url/city/zone/query inputs. The overarching behavior of the tool remains opaque.

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

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

Two short sentences with zero filler; the purpose is front-loaded in the first sentence. Every word earns its place. The slight demotion is for omitting the critical clarification of how the JSON object is provided, which the ultra-brevity sacrifices.

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 9-parameter tool with no output schema and no annotations, the description is markedly incomplete. It fails to identify the actual input carrying the JSON object to count, offers no return-value description, and gives no hint as to why 8 unrelated-parameter slots exist. An agent could not confidently construct a correct call from this definition.

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

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

Schema description coverage is 100%, so the baseline of 3 applies. The description adds the framing 'Count keys... Values discarded' that colors how all parameters should be interpreted, and it correctly matches the schema's own 'discarded after' notes. However, it does not clarify which parameter (if any) supplies the JSON object for key counting, leaving the central semantic gap unresolved.

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

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

The description states a specific action ('Count keys in a JSON object') with an explicit modifier ('Values discarded'), giving a clear core purpose. However, the purpose is undermined by the input schema: none of the 9 parameters represents the JSON object to count, and the closest candidate 'json' is described as 'JSON text to validate' rather than the object whose keys are counted. This disconnect between stated purpose and actual inputs blurs the resource being operated on.

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

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

No guidance is provided on when to use this tool versus alternatives. Siblings like validate-json, lang-sn, and search-query-len all plausibly overlap with 'JSON/key' concerns, yet the description gives no selection criteria. The odd mix of parameters (ref, url, city, feed, host, path, zone, query) that resemble inputs from unrelated sibling tools further obscures the intended usage context.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It transparently states that query and fragment are dropped, which is valuable. However, it does not mention validation behavior, error handling, what happens with invalid URLs, or that many schema parameters are unrelated and discarded.

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

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

Two compact, front-loaded sentences with no filler: the main output is stated first, and the excluded behavior is stated second. This is a model of concise, structured description writing.

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

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

The tool has nine optional parameters, no required parameters, no output schema, and no annotations, yet the description explains only the URL behavior and is silent on return format, shape, or why the schema accepts unrelated parameters. An agent can infer the intended use but lacks enough context to confidently call the tool correctly, especially the structure of the returned origin/host/path object.

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

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

Schema description coverage is 100%, so each parameter has its own schema-level description. The tool description adds some meaning for `url` (it is the input whose origin/host/path are returned) but does not explain why the other eight parameters exist. Baseline 3 is appropriate since the schema covers the parameters, even though the overall input surface is confusing.

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

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

The description states a specific verb and resource: it returns origin, host, and path for a URL, and drops query and fragment. This clearly communicates the tool's main function, though it does not explicitly differentiate itself from sibling tools like browser-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?

The description implies when to use the tool: when you need origin, host, or path components of a URL and you want query/fragment removed. It suggests you should not use it if you need the full URL, but it does not name alternatives or provide explicit when-to-use or when-not-to-use guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'No browser is launched,' which is a single behavioral trait. It does not disclose what happens with each of the nine parameters, what the tool actually does (aside from checking), what the output looks like, or any side effects. This is insufficient for a tool with no annotations.

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

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

The description is extremely concise (one sentence), but it is under-specified, not appropriately concise. Critical information about parameters, usage, and behavior is missing. The brevity fails to be 'front-loaded' with useful content because it contains almost nothing beyond the basic 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?

This is a complex tool with 9 optional parameters, no annotations, no output schema, and many sibling tools. The description provides only a minimal purpose statement and one behavioral note. It is completely inadequate for an agent to correctly select and invoke this tool, especially given the diverse parameters that appear unrelated to the stated purpose.

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 does not add any additional meaning about parameters, which is acceptable since the schema already covers them. However, the parameter set is diverse (url, city, feed, json, path, zone, query, etc.) while the description only mentions checking a URL, creating a mismatch that could confuse an agent. Since the schema is complete, this is a baseline score 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 states a specific verb and resource: 'Check whether a URL can be opened.' It also notes 'No browser is launched,' which hints at a non-browser-based check. However, the meaning of 'can be opened' is ambiguous (syntactic, network, or content check?), and it does not distinguish from siblings like browser-url-ok or fetch-status, which likely perform similar 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?

There is no guidance on when to use this tool versus alternatives. The description provides zero context about scenarios, prerequisites, or exclusions. No sibling tools are mentioned, and no conditions are stated for selecting this tool over others.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It explicitly states 'Query discarded', implying the tool does not retain input and has no side effects. This adds transparency but does not mention whether the operation is read-only, any error conditions, or what happens with remote calls. The 'discarded' note is useful but the description lacks detail on edge cases and output format.

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

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

The description is two short sentences with no redundancy. It front-loads the action ('Count characters') and then a key behavioral note ('Query discarded'). Every sentence earns its place, and the information is immediately clear.

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

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

For a simple tool with 9 optional parameters and no output schema, the description is mostly adequate for the core function. It clearly states the primary action, but it does not explicitly define the return value (e.g., an integer count) or address potential edge cases like empty strings or invalid input. Given its simplicity, a 3 is reasonable; it is not severely incomplete but leaves some ambiguity about output.

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 for all 9 parameters, each with descriptive text. The description adds no additional parameter meaning beyond what the schema already provides; it only highlights the 'query' parameter. Since schema coverage is high, the baseline is 3, and the description does not compensate with extra detail, so a 3 is appropriate.

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

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

The description states a specific action ('Count characters') on a specific resource ('a search query'), which clearly conveys what the tool does. However, it does not mention what the tool returns (e.g., an integer length) and it does not differentiate from siblings like 'hn-front-count' or 'memory-key-count' which also count. The mention of 'search query' helps distinguish, so this is above adequate but not fully distinct.

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 about when to use this tool versus alternatives. The description does not indicate conditions for use, prerequisites, or situations where a sibling tool would be preferable. The agent receives no context about selection criteria, so this dimension is weak.

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 not disclose whether the tool performs network calls, validation, or reference lookups, nor what it returns. The phrasing 'short catalog' suggests a static list, but the parameters imply a checking behavior, which is 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 a single short sentence, which is concise but severely under-specified. It lacks the essential information an agent needs, so the brevity is not effective; it is an under-specification rather than a concise disclosure.

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

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

With nine optional parameters, no output schema, and no annotations, the description provides almost no context. It does not explain the tool's behavior, return value, or how parameters are used. This is completely inadequate for an agent to correctly invoke the tool.

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

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

Schema description coverage is 100%, so each parameter is individually described in the schema. However, the tool description adds no context about why these parameters exist or how they map to HTTP status codes. The mismatch between the stated purpose and the parameters makes the tool confusing, so the description fails to add meaning beyond the raw schema.

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

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

The description states a resource ('catalog of common HTTP status codes') but does not explain how the nine unrelated string parameters (ref, url, city, feed, etc.) relate to that purpose. This creates confusion about what the tool actually does, and it does not distinguish it from siblings like fetch-status or browser-url-ok.

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

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

There is zero guidance on when to use this tool versus the many sibling tools. No mention of intended scenarios, prerequisites, or exclusions. An agent has no basis to select it over alternatives.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It only mentions that the prompt is discarded, but does not state that all parameters are effectively ignored or what happens with the input. The schema hints at discarding, but the description itself is silent on the actual execution 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 very short (two sentences) with no filler, which is structurally concise. However, it's under-specified rather than effectively concise—it omits critical information while being brief, so it doesn't earn its place fully.

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

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

With 9 optional parameters, no output schema, no annotations, and many sibling tools, the description is far too minimal. It does not explain the purpose of the parameters, what the template contains, or why an agent would call this tool. It is incomplete for reliable selection and invocation.

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

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

Schema coverage is 100%, with each parameter having a description (mostly 'discarded after...'). The tool description adds no extra meaning beyond the schema, so it meets the baseline. However, it doesn't clarify why the parameters exist if they are all discarded or what the template depends on, leaving some ambiguity.

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

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

The description clearly states a specific action ('Return a three-step thinking template') with a defined resource. It distinguishes itself from the sibling tools by focusing on a template rather than a check or fetch operation, though it doesn't explicitly compare to any sibling.

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 vs the many siblings. The description gives no context about use cases, prerequisites, or exclusions. An agent cannot determine when 'think-steps' would be appropriate.

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

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

No annotations are provided, and the description does not disclose any behavioral aspects such as side effects, network calls, or whether the tool is read-only. It simply states the function without transparency about potential external dependencies or side effects.

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

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

The description is a single, concise sentence with no redundant words. It is efficient but perhaps too terse, omitting useful context about parameters and usage. Still, it scores well on brevity.

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

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

Given the tool's apparent simplicity, the description lacks essential context such as the expected output format, error behavior for invalid timezone names, and guidance on the many extraneous parameters. The absence of an output schema makes this incompleteness more detrimental, as the agent cannot infer what the tool returns.

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

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

Although the schema descriptions cover 100% of parameters, the description mentions only 'IANA timezone name' while the tool accepts 9 parameters, most of which seem unrelated (ref, url, city, feed, host, json, path, query). The description does little to clarify which parameters are actually used or how they relate to the stated purpose, leaving the large parameter list confusing.

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

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

The description clearly states the tool's function: returning the current time for a named IANA timezone. The verb 'current time' and resource 'IANA timezone' are specific, and the tool name 'timezone' aligns with the description. However, it does not distinguish itself from the sibling 'utc-time' or 'iana-zones' tools beyond the name.

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

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

The description gives no guidance on when to use this tool versus alternatives like 'utc-time' or 'iana-zones'. There is no mention of use cases, prerequisites, or conditions that would make this tool preferable.

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

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

No annotations are present, so the description carries the burden, but it does not disclose whether parameters are ignored, whether side effects occur, or whether the tool requires network access. The schema's oddly unrelated parameters make this omission especially problematic.

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 phrase with no filler. It front-loads the key fact that the tool provides the current UTC timestamp.

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

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

The description is too sparse given the unusual 9-parameter schema and the absence of an output schema. It does not explain why those parameters exist, whether they affect the result, or what format the timestamp is returned in.

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

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

Although the schema has 100% description coverage, the parameters are unrelated to returning a UTC timestamp and the descriptions do not tie them to the tool's function. Some, like 'zone', could mislead an agent into thinking timezone conversion is supported.

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

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

The description 'Current UTC timestamp' clearly identifies the resource and distinguishes the tool from siblings like timezone and iana-zones. It lacks an explicit verb such as 'returns' or 'gets', but the intent is still unambiguous.

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

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

No guidance is given about when to use this tool instead of timezone, iana-zones, or other time-related tools. The description provides no conditional context or alternatives.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does state that the input is 'discarded', which gives some transparency about side effects (non-persistent). But it does not say what happens on invalid versus valid JSON, what the response value looks like, whether any external calls or rate limits are involved, or whether auth is needed. This leaves critical unknown aspects of the tool's behavior.

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

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

The description is very compact—two sentences with no filler—which scores highly for emotional structure. It front-loads the action and immediately states the side effect. The downside is that it's so concise that it fails to cover important required context, but that is a completeness matter per the dimension definitions; conciseness itself is efficient.

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

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

The tool has 9 parameters, no required ones, no output schema, and no annotations. The description only says 'Check whether a body is valid JSON' without explaining which parameter represents the body, what sub-parameters may affect the validation, what a result looks like, or any error behavior. For such a multi-input tool, the description is far too thin—it would leave an agent uncertain about how to invoke it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3; each parameter already has a description mentioning its role and lifecycle. The tool description adds the vague term 'body' without linking it to a specific parameter, which could mislead an agent into passing 'body' or wondering which of several fields is the JSON. It does not add useful parameter semantics; the useful information is in the schema, not the description, and the inconsistency in terminology is not an improvement.

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

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

The description states a clear action ('Check whether a body is valid JSON') and the resource (JSON), so it's not a tautology. However, it never maps 'body' to a parameter in the schema (the closest is 'json'), and it does not distinguish this tool from several shape-check sibling tools that also validate forms (e.g., 'file-path-ok', 'browser-url-ok'). The ambiguity over what 'body' refers to prevents a higher score.

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

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

The description gives no guidance on when to use this tool versus the many shape- and format-checking siblings. There is no mention of which of the 9 parameters must be filled, whether any are mutually exclusive, or what context calls for this specific validator. An agent cannot determine, from the description alone, when to 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?

No annotations are present, so the description carries the main behavioral burden. It communicates a read-only external lookup through Open-Meteo, which is the key behavior; it does not mention rate limits, error conditions, or response units, but those are secondary for a simple non-mutating fetch.

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?

One short sentence contains the full core purpose with no filler. The resource and source are front-loaded, and every word contributes to meaning.

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

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

The description is adequate for a simple weather lookup: it states the input concept and output concept. It still leaves observable gaps around required use of city, ignored extra parameters, and the exact unit/format of the returned temperature, which matters more because there is no output 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?

All nine parameters already have schema descriptions, so the baseline is 3 even though the description adds little parameter detail. The description mentions city, but it does not explicitly warn that the other parameters are ignored or that city is the effective input.

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

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

The description states a concrete output (current temperature), a specific resource (city), and a data source (Open-Meteo), so the core purpose is immediately clear. It does not explicitly contrast any sibling tool, so it stops short of full 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?

The usage situation is implied: use this when you need the current temperature of a city. There is no explicit when-to-use/use-this-instead guidance and no mention of alternative tools such as geo-hint or web-fetch.

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

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

With no annotations, the description carries the behavioral burden. It adds the meaningful detail that the body is discarded, but it leaves other behaviors—redirects, authentication, timeout, error handling, and response shape—unspecified.

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

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

Two short sentences, no filler, no repetition. The key output is front-loaded and the body-discard behavior is added without obscuring 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?

The tool has nine optional parameters, no annotations, and no output schema, but the description only covers a simple URL case. It leaves the agent uncertain about which parameters are relevant or what arguments to pass.

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 already covered by the schema. The description adds minimal parameter meaning beyond implying the 'url' parameter; it does not clarify the roles of the other eight parameters.

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

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

The description clearly states the core operation: it returns HTTP status and content type for a public URL, and explicitly notes the body is discarded. It does not distinguish the tool from siblings like fetch-status or browser-url-ok, so it stops short of a 5.

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

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

The description implies usage—call it when you need a lightweight HTTP status/content-type check and do not need the body. It does not name alternatives, give when-not conditions, or clarify which of the nine optional parameters should be provided.

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

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

With no annotations at all, the full burden of describing behavior falls on the description. It discloses only that the title is discarded, and it does not mention any side effects, external requests, status responses, or correctness edge cases. The mention of 'title' is also suspicious because no title parameter exists in the schema.

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

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

The description is short and front-loaded: two sentences with no filler. However, the second sentence about discarding a title is of limited value because 'title' is not an explicit input; the brevity, despite genuinely concise, is not enough to make the tool callable.

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

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

With no annotations, no output schema, no required parameters, and nine optional fields, the description should provide clarity on how to call the tool, what input carries the title, and what the result looks like. It provides none of that, leaving the tool effectively unusable for an agent.

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

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

Schema descriptions already cover 100% of parameters, giving a baseline of 3, but the description adds no useful param guidance. Worse, it introduces a 'title' concept that is absent from the nine-parameter schema, so the agent cannot map the requested Wikipedia title to any actual parameter.

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

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

The sentence 'Check whether a Wikipedia title exists' states a concrete verb, resource, and action, and it distinguishes this tool from sibling validators like fetch-url's or domain-shape. Some clarity is lost because the input schema contains no 'title' property, but the high-level purpose itself is clear.

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

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

There is no guidance about when to use this tool instead of a sibling such as browser-url-ok, fetch-domain, domain-shape, or search-query-len. No prerequisites, alternatives, or exclusion conditions are mentioned, so agents get no support for tool selection.

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