America/Adak clock

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

Annotations are absent, so the description must carry the burden. It discloses that 'Task text discarded,' which is a useful behavioral detail, and that it returns connection methods. However, it does not explain side effects, permissions, rate limits, or what 'connection methods' actually include. For a tool with no annotation support, this is insufficient transparency about its operational impact.

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

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

The description is three short sentences that front-load the core purpose and include a key behavioral note about discarding task text. It avoids redundancy and is easy to parse. It is efficient without being overly terse, earning a strong conciseness score.

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

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

The tool has 9 optional parameters and no output schema, yet the description provides only a vague return statement ('Returns connection methods'). It does not explain what 'connection methods' are, how to choose which parameter to pass for a given task, or what happens when multiple parameters are provided. This is a significant gap for a flexible gateway-finding tool, making it incomplete for correct invocation.

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

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

Schema description coverage is 100%, so each of the 9 parameters has a clear description. The tool description adds the context that these are hints for the gateway search and that some are discarded, which is slightly beyond schema. However, it does not map specific parameters to specific tasks (e.g., which parameter for 'weather' vs 'voice'), so it does not add substantial meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool's function: finding a public pay-per-call tool gateway for specific task categories (weather, search, scrape, voice). It uses a specific verb ('Find'), a clear resource ('public pay-per-call tool gateway'), and explicitly mentions return value ('connection methods'). This distinguishes it from sibling tools like weather-hint or search-query-len which actually perform the tasks.

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 context about what tasks the tool covers but does not explain when to use this gateway-finder versus directly calling the specific sibling tools. It lacks explicit guidance on when NOT to use this tool or how it relates to alternatives like fetch-status or normalize-url. The task categories are named but no exclusion or selection criteria are provided.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only says 'No browser is launched.' It does not explain whether the tool makes network requests, performs a purely syntactic shape check, has side effects, or what it returns. The schema's 'discarded after the shape check' and 'no disk access' notes add some behavior, but the description itself is thin.

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 and front-loaded with the primary action, and both sentences earn their place. However, it is under-specified for the tool's actual complexity: two short sentences do not adequately describe a nine-parameter tool.

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

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

This is a complex tool with nine optional parameters, no annotations, and no output schema. The description fails to explain how the parameters relate, which one to use for a given intent, what 'opened' means, or what the result looks like. The schema provides some context, but the description is far from complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning beyond the schema, and it actually obscures the relevance of the non-URL parameters. The per-parameter schema descriptions are doing the real semantic 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 clear verb and resource ('Check whether a URL can be opened') and adds a behavioral note ('No browser is launched'), but the input schema exposes eight other unrelated parameters such as city, zone, query, json, and path. An agent cannot tell whether this tool checks URLs only, validates many input shapes, or does something else entirely, so the stated purpose is misleading relative to the schema.

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

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

There is no guidance on when to use this tool versus sibling tools like normalize-url, fetch-status, playwright-url-ok, or domain-shape. 'No browser is launched' hints that this is a non-browser check, but no alternatives or selection 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?

No annotations are provided, so the description must carry the full burden. It only says 'Expression discarded' which is vague and doesn't disclose any side effects, prerequisites, or return behavior. The statement is inconsistent with the actual parameters.

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

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

The description is one sentence, so it is concise, but it contains no useful content. It is under-specified rather than efficiently informative.

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

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

With 9 parameters, no output schema, and no annotations, a minimal description like this is completely inadequate. An agent cannot determine how to call the tool or what it 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?

Schema coverage is 100%, so the baseline is 3. However, the description adds nothing about the parameters and is misleading about the tool's purpose. It fails to connect the parameters to the stated action, so it provides negative 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 claims 'Evaluate a+b style arithmetic' but the input schema has no arithmetic expression parameter. The parameters are for URL, city, JSON, etc., which are unrelated. This is misleading about what the tool actually does.

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

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

No guidance on when to use this tool versus the many sibling tools. The description gives no context for selecting it or excluding 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?

With no annotations, the description carries the full burden. It discloses that 'Page content is not stored,' which is useful, but it does not clarify whether the tool makes network requests, requires authentication, has rate limits, or what happens with the other parameters. For a tool that likely performs HTTP checks, this is insufficient.

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

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

The description is a single, concise sentence that front-loads the primary purpose and includes a relevant note about not storing content. It is efficient and has no fluff, though it may be too terse to fully cover the tool's behavior.

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

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

For a tool with 9 parameters, no output schema, and no annotations, this description is incomplete. It focuses only on 'URL' and ignores the other 8 parameters, leaving their role unclear. It also does not explain return format or any edge cases, making it hard for an agent to call correctly in all contexts.

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

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

Schema description coverage is 100%, so all 9 parameters are documented in the schema. The tool description adds no extra meaning beyond the schema, but it also does not contradict it. Since the schema already provides descriptions, a baseline of 3 is appropriate; the description does not enhance parameter understanding.

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

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

The description clearly states a specific verb and resource: returning host, scheme, and HTTP status for a URL. It is distinct from sibling tools like normalize-url or fetch-status, but it does not explicitly name them, so it only partially differentiates. The core purpose is unambiguous.

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

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

No guidance is given on when to use this tool versus the many sibling tools (e.g., browser-url-ok, fetch-status, normalize-url). The description only states what it does, leaving the agent to infer suitability. There is no mention of exclusions 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?

With no annotations provided, the description carries the full burden, and it does disclose the meaningful behavior 'No identifiers are retained.' However, it does not explain whether inputs are sent somewhere, whether there are side effects, what the response shape is, or why the data is discarded. The privacy note is useful, but the behavioral picture remains incomplete.

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

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

The description is short and front-loaded: the action comes first and the privacy note is a separate, direct sentence. It contains no filler or repetition, though it is under-specified for the number and diversity of parameters.

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

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

Given nine optional parameters, no output schema, and no annotations, the description is not complete enough for reliable invocation. It does not explain the classification output, how many inputs to provide, what parameter combinations mean, or what an agent should do after calling 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?

The schema has 100% description coverage and each parameter already includes its own explanatory text. The tool description adds no parameter-level meaning beyond the generic phrase 'this request', so a baseline 3 is appropriate.

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

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

The description states a clear action ('Show how this request is classified') and a privacy property, but 'classified' is unexplained: it does not say which classification scheme is used, what the result means, or how this differs from sibling tools like validate-json or normalize-url. This is a vague purpose, 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 about when to choose this tool over the many sibling tools, nor whether the caller should pass one parameter, multiple parameters, or all parameter fields. The privacy hint suggests a safe/read-only context, but no concrete use case or alternative is defined.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It only states that the tool operates 'without WHOIS or ownership data,' which is a negative constraint. It does not disclose whether the tool performs network access, what output format to expect, whether it is read-only, or how it handles the various parameter types. 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 a single short sentence, which is concise in length but under-specified for the tool's complexity (9 parameters, no annotations, no output schema). It lacks useful structure or front-loading of key information. Conciseness should not come at the expense of clarity; here it is too terse to be helpful.

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

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

Given the high parameter count (9), zero annotations, no output schema, and no usage guidance, the description is severely incomplete. It does not explain what 'shape' means, how the tool processes different input types, what the output looks like, or any prerequisites or side effects. An agent cannot reliably call this tool correctly with the current information.

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

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

Schema description coverage is 100%, and each parameter already has a clear description (e.g., 'discarded after the shape check'). The tool description adds nothing beyond a single mention of 'hostname' and does not clarify how the parameters relate to each other or which one is primary. Since the schema already documents each parameter, the baseline of 3 is appropriate.

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

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

The description states a specific action (split a hostname into labels) and a resource (hostname), but it does not explain how this relates to the other eight diverse parameters (ref, url, city, feed, json, path, zone, query). It is not a tautology, but it leaves the tool's actual scope ambiguous and does not distinguish it from sibling shape tools like github-repo-shape or figma-url-shape.

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

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

No guidance is provided on when to use this tool versus its siblings. It does not mention any alternative tools, conditions, or scenarios. The description is limited to a single action with no context on selection criteria, so an agent gains no help in choosing this over other 'shape' tools.

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

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

With no annotations, the description carries the full burden, but it only mentions a single behavior (HEAD a URL and return status). It omits that most parameters are discarded after a shape or length check (as noted in the schema), and it doesn't disclose the multi-purpose nature or the actual response semantics beyond 'status only'. This is a serious gap for a tool with such a broad schema.

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

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

The description is extremely concise (one sentence) and front-loaded with 'HEAD a public URL', but it is under-specified rather than concise. It fails to convey the tool's actual breadth, making it both short and ineffective. No structured breakdown of behaviors or conditions is provided.

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

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

Given the tool's complexity (9 optional parameters, no required ones, no output schema) and the presence of many closely related siblings, this description is severely inadequate. It doesn't explain what the status means, when to prefer this tool over alternatives, or how the various parameters influence the outcome. An agent would be lost.

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 described, so a baseline of 3 is warranted. However, the tool description adds nothing about how these parameters relate to the tool's function; it only highlights 'public URL', which could mislead an agent into ignoring the other parameters. The description actually undercuts the schema's clarity by implying only URL matters.

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 ('HEAD a public URL and return status only'), but it is misleading because the schema accepts nine diverse parameters (ref, city, json, path, zone, query, etc.) that suggest the tool performs many kinds of checks, not just URL HEAD requests. It fails to convey the tool's actual scope and does not distinguish it from siblings that cover these individual capabilities.

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

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

There is no guidance on when to use this tool versus any of the 28 sibling tools, many of which appear to cover the exact parameter types (e.g., browser-url-ok, normalize-url, validate-json, timezone). No alternatives, exclusions, or context are mentioned.

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 full burden of behavioral disclosure. It does reveal one meaningful behavior, that the path is discarded, but it says nothing about network access, validation side effects, return behavior, or failure cases. This is partial transparency at best.

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, front-loaded, and free of filler: the main purpose comes first and the discarded-path behavior is a distinct addition. It is somewhat under-specified for a nine-parameter tool, but it is still more concise than padded.

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, and a nine-parameter optional-only input schema, a single sentence is radically insufficient. The description never says which parameters are relevant, what the tool returns, or how the parser behaves in edge cases, so an agent cannot reliably infer the full contract.

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 3. The description does not add meaningful parameter-level semantics beyond the schema, and it never explains why the schema contains many unrelated-looking string parameters such as city, feed, or zone.

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

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

The description specifies a concrete verb and resource: 'Parse a Figma file URL.' It is clear enough for an agent to infer the tool's main job, but it does not explicitly distinguish this from URL-related siblings like normalize-url or browser-url-ok, so it earns a 4 rather than 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?

There is no guidance about when to use this tool instead of alternatives, no mention of preconditions, and no when-not-to-use advice. The agent can only guess from the tool name that this belongs to the family of shape-check tools, which is weak support for routing.

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

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

With no annotations, the description carries the behavioral disclosure burden. The statement 'No disk access' is a useful safety guarantee, but it does not disclose what the tool returns, how safety is determined, or how errors are signaled.

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 zero filler. The core action is front-loaded, and the safety point, 'No disk access', is a valuable second sentence.

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

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

Given 9 optional parameters, no required parameters, and no output schema, the description does not explain how the agent should call the tool meaningfully. It fails to clarify that only the 'path' field is relevant, while the other schema fields appear unrelated and are left unexplained in the tool description.

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

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

Schema coverage is 100%, so the baseline is 3; each parameter has some schema description. The tool description itself adds no semantic detail about the parameters, and it does not clarify the role of the nine optional fields relative to the stated 'path' purpose.

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

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

The description states a specific action ('check whether a path looks safe') on a specific resource ('path'), and the tool name reinforces it. However, it does not differentiate itself from shape-checking siblings such as normalize-url, domain-shape, or wiki-title-ok beyond the word 'path'.

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. The description never mentions alternative tools or the conditions under which file-path-ok should be chosen over a URL or other shape checker, leaving the agent to infer the valid usage context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It fails to mention network dependency, rate limits, what happens to non-'place' parameters (discarded), or that Open-Meteo is an external API call. The schema descriptions allude to side effects (e.g., 'discarded', 'no disk access'), but the tool description itself adds no behavioral transparency.

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

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

The description is one clean sentence with no verbal fat. It front-loads the core action and resource. The drawback is that it is so terse it omits all usage context, but as a concise line it is structurally 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?

With 9 parameters, no annotations, and no output schema, this description is vastly incomplete. It does not tell the agent which parameter to populate, what output format to anticipate, or any constraints. A tool with this many inputs and a single one-line description is essentially unusable without further info.

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

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

Schema description coverage is 100%, so each parameter already has a description. The tool description itself adds no mapping from 'place' to a specific field, e.g., 'city'. Since the schema does the heavy lifting, the baseline of 3 is appropriate.

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

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

The description states a specific action (returns latitude/longitude) and a resource (Open-Meteo), so the core purpose is identifiable. However, it does not map that purpose to any of the 9 input parameters, and nothing distinguishes it from siblings like weather-hint or timezone. The overly terse phrasing leaves room for ambiguity about which parameter is the actual 'place'.

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 guidance is provided. There is no mention of when to choose this tool over siblings, which of the 9 (all optional) parameters are relevant, or what kind of input is expected. The description offers no usage context beyond an implicit 'for a place'.

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 says 'parse' and doesn't explain that the tool likely validates or shape-checks inputs, nor does it mention that many schema parameters are discarded after the check. The mismatch between the description's extraction focus and the schema's 'discarded after the shape check' hints is a significant transparency gap.

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

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

The description is a single concise sentence with no wasted words. However, it is so brief that it omits essential context about the tool's broader behavior, which detracts from its effectiveness despite its efficiency.

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

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

Given the tool has 9 parameters, no output schema, and no annotations, the description is severely under-specified. It doesn't explain the return value, the validation behavior, or how the non-URL parameters are handled. An agent cannot correctly invoke this tool for the full set of inputs described in the schema.

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

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

Schema description coverage is 100%, so each parameter is already documented in the schema. The description adds marginal value by implying the 'url' parameter is a GitHub URL, but it doesn't clarify the role of the other eight parameters. Since the schema does the heavy lifting, a baseline of 3 is appropriate.

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

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

The description clearly states a specific action (parse) on a specific resource (owner and repo from a GitHub URL), which distinguishes it from sibling shape-checking tools like figma-url-shape or jira-key-shape. However, it doesn't account for the broader set of parameters in the schema, which suggest the tool handles more than just GitHub URLs, creating ambiguity about its true scope.

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

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

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention conditions like 'use this when you have a GitHub URL' or direct users to siblings for other URL types. This leaves the agent to infer usage context, which is insufficient.

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

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

With no annotations, the description should disclose any side effects or permissions. It does not mention whether the operation is read-only, makes external requests, or has any limitations, which is a significant gap for a network-related 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 extremely concise, consisting of a single clear sentence. It avoids unnecessary detail and is well-structured for quick comprehension.

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

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

The description is incomplete for the tool's complexity. It fails to explain how parameters relate to the task, what inputs are expected, or what output format to anticipate. The mismatch between the description and the parameter list leaves the agent without essential context.

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

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

The parameter list is entirely mismatched with the tool's stated purpose. The descriptions for parameters like 'url', 'city', and 'query' reference unrelated concepts (normalization, weather, length checks), providing no meaningful guidance for counting stories. The schema coverage is 100% but the descriptions are misleading.

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

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

The description clearly states the action (count) and the target (Hacker News front-page stories). It is specific enough to understand the tool's core function, though it does not explicitly contrast with sibling tools like web-fetch 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 provides no guidance on when to use this tool over alternatives. It only states what it does, leaving the agent to infer appropriate usage contexts.

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

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

No annotations are provided, so the description carries full responsibility. It does not disclose any behavior—side effects, return format, data source, or whether it performs any validation. The tool might return a static list or interact with external data, but nothing 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?

The description is a single short sentence, so it's concise, but it's under-specified. It front-loads a vague noun phrase and omits essential action and context. Conciseness is only good when it includes the necessary information; here it doesn't.

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, this description is grossly incomplete. An agent has no idea what to input, what the tool returns, or when to use it. Even the tool's core function (returning a list? validating?) is ambiguous, making it impossible to use correctly.

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

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

While the schema covers all 9 parameters with individual descriptions, the tool description does not explain how any of them relate to the stated purpose of providing timezone names. For example, why does a timezone-name tool accept 'url' or 'host'? The description adds no value in linking parameters to functionality, leaving the agent confused about what to pass.

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

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

The description 'Common IANA timezone names for clock calls' identifies a resource (timezone names) but lacks a verb or explicit action. It's a noun phrase, not a statement of what the tool does—does it return a list, validate a name, or something else? The schema includes 9 unrelated optional parameters (url, city, feed, etc.), which further muddies the purpose. It's more than a tautology but still vague.

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

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

There is no guidance on when to use this tool versus siblings like 'timezone', 'tz-america-adak', or 'utc-time'. No context about typical use cases, prerequisites, or exclusions. An agent cannot decide when to invoke 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?

Since no annotations are provided, the description bears the full burden. It implies a read-only network fetch and notes the output is only group counts, but it does not explain which parameters are actually used to locate the robots.txt, nor what happens on errors, unreachable hosts, or rate limits. The behavioral disclosure is minimal.

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

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

The description is a single efficient sentence that front-loads the action and limits the output scope. There is no wasted wording or redundant detail.

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

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

With 9 non-required parameters, no annotations, and no output schema, the description is too sparse. It does not say how the agent should select the correct parameter for the robots.txt URL, what 'group counts' actually means, or what a typical response looks like. This leaves significant gaps for correct invocation.

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

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

Schema description coverage is 100%, so all 9 parameters are individually described in the schema. The tool description adds no extra parameter context, such as which parameter is the required URL or host for the robots fetch. Per the baseline rule, this is a 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 'Fetch a public robots.txt and return group counts only' states a specific verb (Fetch), a specific resource (public robots.txt), and a specific output (group counts only). This clearly distinguishes it from generic fetch tools like web-fetch 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 gives no explicit guidance on when to use this tool versus alternatives such as web-fetch or fetch-status, and does not mention when it is appropriate or inappropriate to invoke. It only states what it does, leaving the decision entirely to the agent.

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

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

Annotations are absent, so the description must disclose behavior. It mentions 'Key discarded,' implying the input is not retained, but it does not state whether the tool returns a boolean, performs network access, or has any side effects. The description leaves the agent unsure about output and operational characteristics.

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

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

The description is very short and front-loaded with the purpose, which is good for conciseness. However, it omits critical information about which parameter to use and expected behavior, so it is under-specified rather than appropriately concise. It is not a tautology, but it does not earn a higher score because of the missing essential details.

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

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

With 9 parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain which parameter is the Jira key, what shape is expected, what the return value is, or any side effects. An agent cannot correctly invoke this tool based on the description alone.

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

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

Schema coverage is 100%, so the schema describes each parameter's type and meaning, but none relate to a Jira key. The description does not clarify which parameter is the key or how the Jira key shape is applied. Since the schema descriptions are for unrelated domains (e.g., city for weather, JSON for validation), the description fails to bridge the gap between the tool's purpose and its parameters.

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

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

The description states a specific verb and resource: 'Check a Jira issue key shape.' This distinguishes it from sibling shape-checkers like github-repo-shape. However, it does not indicate which of the 9 schema parameters holds the Jira key, and the schema lists unrelated fields (ref, url, city, etc.), creating ambiguity about how to invoke the tool. The purpose is clear in intent but not in practical usage.

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

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

No guidance is given on when to use this tool versus alternatives. It does not mention other shape-checking tools, nor does it describe the expected Jira key format or any prerequisites. An agent has no way to know whether this tool is appropriate for a given input or how it differs from sibling tools.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the body is discarded and that it returns an HTTP status, but it completely fails to explain how the other parameters (e.g., 'city' for weather, 'zone' for timezone) behave or what side effects occur. The description is inconsistent with the parameter set, leaving the agent guessing about the actual behavior.

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

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

The description is extremely short (two fragments) but that is under-specification, not conciseness. It lacks any structure that would help an agent parse the tool's scope, and the single behavior stated (HTTP status) is contradicted by the schema's diversity.

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

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

With 9 parameters, no output schema, and no annotations, this description is grossly inadequate. It does not explain the return value (beyond 'HTTP status'), how each parameter is used, or when the tool is appropriate. An agent cannot safely call this tool based on the description alone.

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

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

Although the schema provides descriptions for all 9 parameters (100% coverage), the tool description does not add any semantic value and actively misleads about which parameters are relevant. The description singles out a 'library docs URL' while the schema includes weather, JSON, timezone, and search parameters, so an agent would not understand how these parameters relate to the stated purpose.

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

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

The description claims 'HTTP status for a public library docs URL,' implying a narrow fetch-status operation, but the schema exposes 9 unrelated parameters (city, zone, json, path, query, etc.). This is actively misleading about the tool's actual purpose and 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?

No guidance on when to use this tool versus alternatives, and no mention of which parameters are relevant for which use cases. The description does not clarify that the tool appears to handle many distinct hint types (weather, timezone, JSON validation, etc.), so an agent cannot decide when to invoke it.

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

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

With no annotations, the description must disclose behavioral traits itself. It only states 'Values discarded,' which reveals the core behavior but omits critical details: What if input is not a valid JSON object? Does it error? Does it access disk or network? The schema descriptions for parameters are inconsistent (e.g., 'json' says 'validate' while tool says 'count'), adding confusion rather than transparency.

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

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

The description is only two sentences and is front-loaded with the core purpose. There is no redundant wording. However, the extreme brevity borders on under-specification, but for the metric of conciseness it is efficient and earns its place.

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

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

Given 9 parameters, no annotations, and no output schema, the description is severely incomplete. It does not explain how to provide input, what the output is (beyond a count), what constitutes a valid JSON object, or why multiple unrelated parameters exist. An agent cannot reliably call this tool based on the given 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?

Although schema coverage is 100%, the tool description adds no parameter clarification. The parameter descriptions are vague and sometimes contradictory—e.g., 'ref' says 'discarded after the shape check' and 'json' says 'to validate', which do not align with the tool's stated purpose of counting keys. The description does not indicate which parameter is the primary input, leaving agents unable to construct a correct call.

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

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

The description states the specific operation: 'Count keys in a JSON object. Values discarded.' This is a clear verb+resource. However, it does not differentiate from sibling tools like validate-json or domain-shape, which also deal with JSON structure. Still, the core purpose is unambiguous.

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

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

The description provides no guidance on when to use this tool versus siblings. It does not mention any prerequisites, alternatives, or contextual triggers. An agent has no basis to decide between this and validate-json or other 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?

The description discloses a meaningful behavioral detail: query and fragment are dropped. However, with no annotations provided, it does not mention error behavior, whether the other schema parameters are ignored, or any side effects; the read-only nature is left implicit.

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

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

Two sentences with no filler. The primary behavior is front-loaded and the key transformation (dropping query and fragment) is stated immediately.

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 a nine-parameter schema and no output schema or annotations, the description is too thin. It does not explain why the other parameters exist, whether they are ignored, or what the return format looks like beyond naming three components, leaving an agent uncertain about how to invoke the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters. The description adds the URL-specific behavior of dropping query and fragment, but it does not clarify how the eight non-URL parameters relate to the tool's purpose.

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

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

The description states a specific verb ('Return') and resource ('a URL') and names the exact output components: origin, host, and path. It clearly focuses on normalization rather than checking or fetching, though it does not explicitly differentiate itself from sibling tools.

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

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

No guidance is given on when to use this tool versus siblings like browser-url-ok, playwright-url-ok, domain-shape, or web-fetch. The description implies use for extracting normalized URL components but provides no exclusions or alternative routing.

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

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

With no annotations, the description carries the full burden of disclosing behavior. It states only that 'No browser is launched,' which is a useful negative constraint, but it does not explain how the check is performed (e.g., network request, DNS lookup, syntax validation), what constitutes 'can be opened,' or what the return value looks like. This is a significant gap for a tool with no other behavioral metadata.

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 exceptionally concise at two short sentences with no filler. It front-loads the core purpose first, then adds a key behavioral caveat. This is efficient and well-structured, though it sacrifices depth for brevity. The conciseness is appropriate, but the structure does not earn the top score because it omits crucial context.

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

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

The description is severely incomplete given the tool's complexity. It has 9 optional parameters with no required ones, and the description does not explain how they relate to the core function (e.g., why 'city' or 'json' matter). There is no output schema, and the description gives no indication of what the tool returns or how results are expressed. An agent cannot reliably decide when to call this tool or how to interpret its output based solely on this description.

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

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

Schema coverage is 100% with each of the 9 parameters having a description, so the baseline is 3. The tool description adds no additional parameter context or relationships beyond the schema. Since the schema is detailed, the tool's lack of parameter explanation does not lower the score, but the description also does not enrich the semantics beyond what the schema already provides.

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

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

The description states a clear verb ('check whether a URL can be opened') and a specific resource (URL). It also adds a distinguishing trait ('No browser is launched') which implicitly differentiates it from siblings like browser-url-ok, but it does not explicitly name any alternative. The purpose is clear and specific enough for an agent to understand the core function, though sibling differentiation is only implicit.

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 the many siblings (browser-url-ok, fetch-status, normalize-url, etc.). It does not mention contexts where it would be preferred, nor does it indicate any prerequisites, limitations, or alternatives. An agent has to infer usage from the name and description alone, which is insufficient.

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

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

With no annotations, the description carries the behavioral burden. It discloses that the query is discarded, which is useful transparency, and implies a read-only operation. However, it does not describe the return value format or any error behavior, which would strengthen the description. For a simple counting tool, this is adequate but not comprehensive.

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

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

The description is two short sentences with no waste. The key operation is stated upfront, and the discard behavior is a meaningful addition. It is appropriately sized for the tool's simplicity.

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

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

With 9 optional parameters and no output schema, the description is incomplete. It does not specify which parameter(s) to pass, what the tool returns, or how multiple inputs are handled. An agent would need more details to reliably invoke this tool correctly, especially given the wide parameter variety.

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

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

Schema description coverage is 100%, so the baseline is 3. However, the description only references 'search query', which presumably maps to the 'query' parameter, but the tool has 8 other parameters with no explanation of how they relate. The description does not clarify whether the tool counts characters in any provided string or only the 'query' parameter, and the mention of 'search query' is ambiguous given the broad set of string parameters. Thus it falls below the baseline.

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

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

The description clearly states the verb 'count' and the resource 'search query', making the purpose specific. However, it does not differentiate from sibling tools like memory-key-count or hn-front-count, which also count things, so it loses the full mark for sibling differentiation.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention any context, prerequisites, or exclusions, leaving the agent 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?

No annotations are provided, so the description must carry the full burden of behavioral disclosure, and it discloses nothing. It does not state side effects, return format, error behavior, or that calls are likely read-only. The schema's 'discarded after the check' notes hint at side-effect-free checks, but the description itself adds zero behavioral context.

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

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

A single six-word sentence with zero waste, and the core noun is front-loaded. But this is under-specification rather than disciplined conciseness — 'Short catalog' is soft filler and the sentence omits nearly all operative detail. It is efficiently short at the cost of being nearly content-free.

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

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

For a tool with 9 parameters, no output schema, and no annotations, a one-line noun phrase is drastically inadequate. Nothing explains what the catalog returns, how any of the 9 parameters map to a status-code lookup, or what 'discarded' semantics mean operationally. This is far below the minimum viable level for a tool of this complexity.

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

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

Schema description coverage is 100%, so the baseline is 3 even without parameter info in the description. The description adds nothing about parameters, and worse, it fails to reconcile the bizarre collection of parameters (Git ref, city weather hint, timezone, JSON validation, file path) with the stated 'HTTP status codes' purpose. Given full schema coverage, 3 is the correct baseline, but the description earns no credit for clarifying how these params relate.

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

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

The description names a specific resource ('catalog of common HTTP status codes') which is more than a tautology and roughly distinguishes from siblings like fetch-status or browser-url-ok. However, it is a noun phrase, not a verb+resource, so it never states what operation the tool performs (list codes? look up one code?). The disconnect is severe: the 9 input parameters (ref, url, city, feed, host, json, path, zone, query) have no evident relationship to HTTP status codes, so the purpose is materially obscured.

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 usage guidance whatsoever. The description never says when to call this tool versus any of its 28 siblings, several of which (fetch-status, inspect-robots, web-fetch) overlap with the HTTP/status domain. An agent has no basis to select or exclude this tool.

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

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

No annotations are provided, so the description must disclose behavior. It only says 'Prompt discarded,' which is ambiguous and does not explain how the tool handles the nine input parameters, what side effects exist, or what it actually returns beyond a vague 'template.' The schema hints at parameter discarding, but the description itself is opaque.

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

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

The description is extremely short and front-loaded, with no wasted words. It is efficient, though its brevity contributes to the lack of substance.

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

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

With 9 optional parameters and no output schema, the description leaves too much unspecified. It does not describe the return format, how the parameters relate to the output, or what 'three-step thinking template' means in practice. An agent cannot confidently invoke this tool based on the description alone.

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

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

Schema description coverage is 100%, so the parameters are individually documented (e.g., 'discarded after the shape check'). The description adds no additional meaning about the parameters, but the baseline of 3 applies because the schema already covers them.

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 ('Return a three-step thinking template'), but it is vague about what the template is, what it contains, or how it should be used. It does not differentiate from siblings, and 'Prompt discarded' adds ambiguity rather than clarity.

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

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

There is no guidance on when to use this tool or why it might be preferred over alternatives. No context is given about its intended role among the many sibling tools.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It only states the core function and provides no details on output format, error handling, side effects, or the fact that most input parameters are discarded. This is a severe gap for a tool with 9 parameters.

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

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

The description is a single sentence, which is efficient, but it is under-specified. It omits essential information such as how the other parameters are handled and what the output looks like. It is not concise in the sense of packing value; it is simply too brief.

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

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

Given the tool has 9 parameters, all optional, and no output schema, the description is drastically incomplete. It doesn't explain the purpose of the extraneous parameters, doesn't mention that they are ignored, and doesn't describe the response format. An agent cannot call this tool correctly without guessing.

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 covers all 9 parameters with descriptions (100% coverage), so the baseline is 3. However, the tool description only mentions 'named IANA timezone', implying 'zone' is the meaningful parameter, but it does not clarify that the other eight parameters are ignored or what their roles are. The description adds no extra meaning and leaves the agent uncertain about which parameters matter.

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

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

The description clearly states the function: 'Current time in a named IANA timezone.' It specifies a concrete resource and action. However, it does not differentiate from siblings like utc-time or tz-america-adak, which also deal with timezones, so clarity is not perfect.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention that 'zone' is the relevant parameter or that other parameters are ignored. An agent cannot determine when to prefer this over utc-time or iana-zones.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states only the output (current local time) and does not disclose whether it performs network calls, whether it is read-only, or how it handles the nine input parameters. The description is silent on any side effects or limitations.

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

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

The description is a single, front-loaded sentence with zero wasted words. It is extremely concise and immediately conveys the core purpose. While it is minimal, conciseness is judged on efficiency, and this achieves it perfectly.

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, the description is far from complete. It does not specify the return format (e.g., string, ISO date), how parameters affect behavior, or what distinguishes it from the many sibling tools. An agent would struggle to call it correctly without additional context.

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

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

Although the schema provides 100% coverage of parameter descriptions, the tool description does not explain which of the nine optional parameters are relevant. For a tool fixed to America/Adak, the 'zone' parameter is puzzling, and the description does not clarify whether parameters are ignored or used. The description adds no meaning beyond the schema and fails to reconcile the fixed timezone with the presence of a zone parameter.

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

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

The description 'Current local time in America/Adak' clearly states the action (returns current local time) and the specific resource (America/Adak timezone). It is unambiguous about what it returns and is distinct from siblings like utc-time or timezone, though it does not explicitly contrast itself with them.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention that it is specific to America/Adak or that other timezone tools should be used for different zones. The description gives no context for selecting this tool over its 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 existed. The description says only what the tool returns. It provides no behavioral details about side effects or discards of parameters, but the input schema descriptions already state that parameters are discarded after checks. The description itself does not disclose the side effect of not using parts of the schema, so it partially relies on 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 a single, short sentence with one key fact. It is not verbose and is front-loaded. It is appropriately minimal for the simplicity of the core behavior, though it could have added a note about the ignored parameters.

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 core behavior (return current UTC timestamp) is fully stated, but the schema contains nine optional parameters that all carry a 'discarded' note, and the description does not clarify that these parameters are irrelevant. An agent may wonder if calling with a URL or JSON affects the time. A fuller explanation such as 'any provided arguments are ignored' would increase completeness.

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 description explains that they are discarded after shape or other checks. The tool description adds no information about parameters. Therefore the baseline score of 3 is appropriate, as the schema does the heavy lifting.

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

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

The description states the tool returns the current UTC timestamp, which is only a generic action, and the resource is a timestamp. It is not a tautology and distinguishes it from other time-related tools implicitly, but it does not explicitly compare with siblings like timezone or iana-zones.

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 the implied use case: when the current UTC timestamp is needed. It does not state alternatives such as timezone for a specific timezone or mention exclusions. No explicit when-not statements are present.

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 usefully states that the body is discarded, implying no persistence or side effects, but does not disclose return behavior, handling of invalid JSON, or any external interactions. This is minimally transparent but not misleading.

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 filler, and the core purpose is front-loaded. It is concise, though so brief that it leaves contextual gaps addressed in other dimensions.

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?

There is no output schema, so the description should clarify the return value or check semantics, but it does not. It also leaves unclear which parameter must be supplied, especially given 9 optional parameters; the agent is left to infer that `json` is relevant.

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

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

Schema description coverage is 100%, so the parameters are already individually explained. However, the description refers to 'a body' while the schema exposes a `json` parameter, creating a slight mapping gap; the schema's own parameter description compensates for this.

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 on a specific resource: check whether a body is valid JSON. It is distinguishable from sibling shape/status tools by its validation focus, though it does not explicitly contrast itself with 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?

No guidance is given about when to choose validate-json over alternatives such as domain-shape, figma-url-shape, or file-path-ok. The description implies its use through the name and purpose, but offers no explicit when/when-not guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It claims temperature retrieval but does not disclose that most parameters are discarded after a shape check (as indicated by schema descriptions), nor does it describe the actual behavior for non-city inputs. This omission is misleading and fails to convey the tool's true scope.

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

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

The description is a single sentence, which is concise, but it is under-specified rather than well-structured. It lacks any front-loaded key details or hierarchical organization, and the brevity comes at the cost of essential information.

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

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

Given 9 parameters, no output schema, and no annotations, a one-line description is grossly insufficient. It only addresses the city aspect while ignoring the other eight parameters, and it fails to explain the tool's role as a general 'hint' checker. The description is far from complete for an agent to use it correctly.

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

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

The schema provides 100% coverage with descriptions for all 9 parameters, including 'City name for a public weather hint; discarded after the call'. The tool description adds no new parameter semantics beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description states 'Current temperature for a city via Open-Meteo', which is a clear purpose for the city case, but the input schema includes 9 parameters (ref, url, feed, host, json, path, zone, query) unrelated to temperature. This suggests the tool is actually a multi-purpose 'hint' validator, making the description narrow and potentially misleading. It also does not differentiate from sibling tools like geo-hint or timezone.

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

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

The description provides zero guidance on when to use this tool versus alternatives. No mention of context, prerequisites, or exclusions exists, leaving the agent without any 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, the description carries the full burden of behavioral disclosure. It does state 'Body discarded,' which is a useful behavioral detail, but it omits critical information such as whether the tool makes network requests, follows redirects, returns only status codes or also headers, and how the other parameters behave. It also fails to disclose that the tool handles multiple check types beyond URLs, making it appear simpler than it is.

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 and front-loaded: two short sentences. It does not waste words, and the key idea (status/content type, body discarded) is placed early. However, its brevity comes at the cost of completeness, though that is a separate dimension. Structurally, it 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 annotations, and no output schema, so the description must carry a heavy informational load. It fails almost entirely: it addresses only one of many use cases, provides no indication of the other check types, and offers no output format or error behavior. An agent would be severely under-informed about how to invoke this tool correctly for any non-URL parameter.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds no value for parameters and actually misleads by implying only 'url' is relevant. The schema already documents each parameter, but the description does not clarify that the tool performs distinct checks (JSON validation, timezone, path, etc.). It fails to compensate for the lack of overall context.

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 primary purpose for the url parameter ('HTTP status and content type for a public URL'), but it ignores the other eight parameters (ref, city, feed, host, json, path, zone, query) that the schema supports. As a result, it only conveys a fraction of the tool's actual purpose, leaving an agent with an incomplete and somewhat misleading understanding.

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 does not mention alternatives, conditions, or exclusions, leaving the agent to guess which tool fits a given scenario.

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

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

With no annotations, the description carries the full burden. It only discloses that the title is discarded after the call, which is a minor detail. It does not state read-only behavior, side effects, permissions, or limitations, and it is inconsistent with the generic parameters.

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

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

The description is concise, one sentence, and front-loads the core action. However, it is so brief that it omits essential information like which parameter to use, making it under-specified rather than efficiently concise.

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

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

Given nine parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain how to specify the title, what the other parameters are for, what the return value is, or any usage context. An agent cannot reliably call this tool correctly.

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

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

Schema coverage is 100% with each parameter having a description, but these descriptions are generic (e.g., 'Git ref name', 'City name') and do not relate to Wikipedia titles. The tool description implies a title parameter but none exists in the schema, so the semantics are confusing and do not add meaningful value.

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

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

The description states a clear action—'Check whether a Wikipedia title exists'—which distinguishes it from sibling tools like browser-url-ok or file-path-ok. However, it fails to indicate which of the nine parameters carries the title, making the purpose ambiguous despite the verb+resource.

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

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

No guidance is given on when to use this tool versus alternatives. It does not mention that it is for Wikipedia title checks specifically, nor does it contrast with sibling tools or state any conditions or exclusions.

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