PSI to kilopascals

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

With no annotations, the description carries the full burden. It discloses one behavioral trait ('Task text discarded') and says it returns connection methods, but does not mention side effects, external calls, rate limits, or whether the tool is read-only. The minimal disclosure is adequate for a finder but lacks depth.

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

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

The description is a single, front-loaded sentence that states the purpose, gives examples, and notes the discard behavior with zero fluff. It is concise and well-structured, earning a high score for 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?

Despite having 9 optional parameters and no output schema, the description does not explain how parameters map to tasks, which parameters are relevant for which scenario, or what 'connection methods' entails. An agent would struggle to decide which parameter to populate without additional context. The schema descriptions help but are not sufficient for this complex tool.

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

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

Schema description coverage is 100%, so each parameter already has a description. The tool description adds little beyond the schema—only the general note that task text is discarded, which is already partially reflected in individual parameter descriptions (e.g., 'discarded after the shape check'). No extra meaning is provided.

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

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

The description uses a specific verb (find) and a specific resource (public pay-per-call tool gateway), and gives concrete example tasks (weather, search, scrape, voice). It also states what it returns (connection methods), clearly distinguishing it from sibling tools that perform specific operations rather than discovering gateways.

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

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

The description implies usage for tasks like weather, search, scrape, or voice, but does not explicitly state when to use this tool versus the many specific sibling tools (e.g., weather-hint, search-query-len). It offers no exclusions or direct alternatives, leaving the routing decision to inference.

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

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

With no annotations, the description must fully disclose behavior, but it only mentions that no browser is launched. It fails to explain what 'can be opened' means (syntactic check, DNS resolution, HTTP status?), what the tool returns, or why most parameters are discarded after a 'shape check.' The schema descriptions add confusion rather than clarity, so the description provides almost no useful behavioral detail.

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

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

The description is concise (two sentences) and front-loads the core action, which is good. However, it is so terse that it omits essential details about the tool's actual behavior and parameter handling. It is not redundant, but it is under-specified to the point of being unhelpful.

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

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

For a tool with nine optional parameters, no required fields, no output schema, and no annotations, the description is grossly inadequate. It leaves the agent without any understanding of what the tool does beyond a vague URL check, what outputs to expect, or how the various parameters are used. The definition is incomplete for effective tool selection and invocation.

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

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

Schema description coverage is 100%, so the baseline is 3, but the parameter descriptions are incongruent with the stated purpose. For example, 'city' is for a weather hint and 'json' is for validation, yet the tool claims to check URL openability. The tool description adds no explanation for these parameters and does not clarify how they relate to the URL check, so it fails to compensate for the schema's disjointed semantics.

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

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

The description states a specific action ('check whether a URL can be opened') and a constraint ('No browser is launched'), but the input schema includes nine unrelated parameters (e.g., city, json, zone, query) that are described as discarded after shape checks. This mismatch makes the tool's actual purpose ambiguous and misleading—the description does not cover the full scope implied by the schema.

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

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

No guidance is provided on when to use this tool versus the many siblings (e.g., playwright-url-ok, normalize-url, fetch-status). The 'No browser is launched' hint suggests a lightweight alternative to a browser-based check, but this is not stated explicitly, and no alternatives or conditions are given.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Expression discarded,' which hints at a side effect but gives no detail about what the tool actually does with the input, what it returns, or whether it performs any real computation. The mismatch with the schema compounds the opacity.

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

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

The description is extremely short, but this is under-specification rather than conciseness. It consists of two fragments that do not explain the tool's purpose or usage. Every word is wasted because it describes behavior that the schema does not support.

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

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

The tool has nine parameters, no required fields, no output schema, and no annotations. The description provides almost no context about what the tool does, what inputs are meaningful, what the result looks like, or when to use it. This is grossly inadequate for an agent to invoke the tool correctly.

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

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

Although the schema has 100% description coverage for its nine parameters, the tool description does not reference any of them. The phrase 'a+b style arithmetic' does not map to any schema property, so the description adds zero meaning and actually contradicts the schema's content. This fails to compensate for any gap and introduces confusion.

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 ('Evaluate a+b style arithmetic') but it is entirely disconnected from the input schema, which contains unrelated parameters like url, city, and feed. This is not a tautology, but it is misleading because the described behavior does not match the actual tool interface, and it does not distinguish the tool from its many siblings.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any context, prerequisites, or exclusions. An agent would have no way to know if this tool is appropriate for a given task or how it relates to sibling tools like timezone or validate-json.

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

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

The description discloses that page content is not stored, but it leaves side effects implicit, such as whether a network request is made and that most input fields are discarded. With no annotations, this is only partial 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 a single clear sentence with no filler or redundancy. It is easy to parse.

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

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

With nine optional parameters, no output schema, and no annotations, the description is too sparse to fully guide a caller; it omits the expected input selection, return format, and side-effect behavior.

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

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

The schema descriptions are explicit for every property, but the description does not clarify how the many unrelated parameters relate to the URL-focused behavior or which ones should be supplied. It adds little beyond the schema.

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

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

The description states the concrete outcome: return host, scheme, and HTTP status for a URL. It is clear but does not differentiate from sibling URL/status tools such as fetch-status or web-fetch.

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 about when to choose this tool over siblings or what conditions make it appropriate. The privacy note about page content is not a usage criterion.

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

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

With no annotations provided, the description carries full responsibility for disclosing behavior. It only mentions 'No identifiers are retained,' which is a privacy note but does not explain side effects, return format, or any processing steps. The tool's actual behavior remains opaque.

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

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

The description is a single sentence with no filler, which is structurally clean and front-loaded. However, its brevity is a liability given the tool's complexity; it earns its place but is insufficient for the scope.

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

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

The tool has 9 parameters, no output schema, and no annotations, yet the description offers only a cryptic one-liner. It does not explain what the tool returns, how the parameters combine, or what 'classified' means, making it inadequate for correct invocation.

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

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

The schema coverage is 100% and each parameter already has descriptive text (e.g., 'Git ref name; discarded after the shape check'). The description adds no additional meaning to the parameters, so it neither helps nor hurts. Baseline of 3 is appropriate for high coverage.

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

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

The description 'Show how this request is classified' is vague and does not specify what classification is performed, what output to expect, or how it relates to the parameters. It fails to distinguish this tool from siblings like 'domain-shape' or 'validate-json' which have clear purposes.

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 guess the appropriate scenario for invocation.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. It only mentions that WHOIS/ownership data is not retrieved, but says nothing about side effects, return values, whether parameters are discarded, or any other behavioral traits. The schema descriptions hint at some discarding, but the main description does not disclose this, so an agent cannot predict the tool's full behavior.

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

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

The description is a single sentence with no fluff, front-loading the core action and adding a brief scope limitation ('without WHOIS or ownership data'). It is appropriately concise, though the brevity comes at the cost of missing essential context.

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

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

The tool has 9 parameters and no output schema, and the description covers only a narrow hostname-splitting action. It does not explain what the tool does with URLs, JSON, timezones, queries, or other inputs, nor what it returns. This is grossly incomplete for such a parameter-rich 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 provides 100% description coverage, so each parameter is documented. However, the description's focus on 'hostname' only aligns with the 'host' parameter, leaving the other eight parameters unexplained in the description. The description does not clarify why these parameters exist or how they relate to the stated purpose, creating a semantic mismatch that could confuse an agent.

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), which is clear for that narrow case. However, it does not explain the tool's overall purpose given the input schema accepts 9 diverse parameters (ref, url, city, feed, json, path, zone, query) that have nothing to do with hostnames, making the tool's scope confusing and failing to differentiate from siblings like figma-url-shape or github-repo-shape.

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

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

No guidance is given on when to use this tool versus alternatives. There is no mention of conditions like 'use when you have a hostname to split' or exclusions such as 'do not use for WHOIS lookups'. The description leaves the agent to infer usage entirely.

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?

As no annotations are provided, the description carries the full burden. It clearly discloses that this is a HEAD request (non-destructive, no body) and that it works only on public URLs. However, it is silent about the tool's many other parameters (city, feed, json, path, zone, query) and how they interrelate, leaving the behavioral model incomplete for these inputs.

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

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

The description is one tight sentence that is front-loaded with the action (HEAD) and the outcome (status only). Every word earns its place; there is no filler. It effectively communicates the essential purpose in the fewest words.

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

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

With 9 parameters and no output schema, the description is far too minimal to be contextually complete. It only explains the `url` usage, leaving all other parameters unexplained in the overall behavior. Even though the schema has 100% coverage, the description's silence on how these parameters are used (or ignored) would confuse an agent trying to invoke the tool for a non-URL input. A more complete description would clarify the multi-purpose nature of the tool.

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

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

Schema coverage is 100%, so the baseline is 3 even without extra parameter information. The description adds no meaning beyond the schema itself; it only says 'HEAD a public URL', which indirectly matches the 'url' parameter but does not explain the relevance of the 8 other parameters. Given the schema is thoroughly documented, the description simply doesn't augment it.

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

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

The description states the verb (HEAD), the resource (public URL), and the expected output (status only), making the tool's purpose immediately clear. It distinguishes this tool from content-fetching siblings like web-fetch and browser-url-ok, which would retrieve more than status. The phrase 'status only' sets precise expectations.

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

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

The description implies usage: use it when only the status of a public URL is needed, but it never explicitly names alternative tools or conditions for choosing this one. With siblings like browser-url-ok and playwright-url-ok, the lack of an explicit 'use this instead when X' leaves some inference to the agent. It gets a 3 because the purpose strongly implies the situation, but no direct guidance is provided.

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

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

With no annotations, the description must carry full behavioral disclosure. It only mentions 'Path discarded,' which is cryptic—it could refer to the URL path or the 'path' parameter. It does not disclose what the tool returns, how it validates, or any side effects. This is a significant gap for a tool with no annotations.

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

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

The description is extremely short (two sentences) and front-loads the purpose, but it is under-specified. It omits critical information that an agent needs, such as what constitutes a valid Figma URL and how other parameters behave. The brevity does not serve completeness; it feels like a placeholder rather than a polished, efficient description.

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

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

Given the tool's apparent complexity—9 parameters, many seemingly unrelated to Figma URLs—and the absence of an output schema, the description is incomplete. It does not explain how the parameters interact, what the tool returns, or which parameter is the input. The mismatch between the description and the parameter list is a notable gap that leaves an agent 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. The tool description does not add any parameter-specific meaning; it does not even identify which parameter is the Figma URL. It relies entirely on the schema, which is adequate but does not clarify the relationship between the described behavior and the 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 clear verb and resource: 'Parse a Figma file URL.' It distinguishes from sibling shape-check tools by targeting Figma URLs specifically. However, it does not explicitly contrast with alternatives like browser-url-ok or domain-shape, and the phrase 'Path 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?

No guidance is provided on when to use this tool versus other shape-checking tools. There is no mention of alternatives, exclusions, or conditions that would select this tool over siblings. The only implicit hint is the 'Figma' specificity, but that is not made explicit as a decision rule.

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

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

The description discloses that no disk access occurs, and several parameter descriptions note values are discarded. However, with no annotations and no output schema, it does not explain return behavior, errors, or other possible side effects.

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

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

The description is extremely concise and front-loaded, with no filler or redundant sentences. Every word contributes to the core message.

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

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

Despite the terse description, the tool has 9 optional parameters, no output schema, and no usage guidance. The meaning of 'safe', the expected return value, and how the unrelated parameters relate to the tool's purpose are all missing, making it incomplete for an agent.

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

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

All 9 parameters have descriptions in the schema and each one adds semantic context, such as 'Git ref name; discarded after the shape check' and 'File path to check; no disk access'. The descriptions are clear individually, though their relationship to a path-safety tool is unexplained.

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 ('Check whether a path looks safe') and the key constraint ('No disk access'), which distinguishes it from disk-accessing tools. However, 'safe' is left undefined and the large set of unrelated parameters makes the exact scope less crisp.

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 the many sibling tools, and no conditions or alternatives are mentioned. The 'No disk access' note is useful but not enough to orient an agent.

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

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

With no annotations provided, the description carries the full burden. It mentions using Open-Meteo but does not disclose network behavior, rate limits, error handling, or what happens to inputs. Several parameters are said to be 'discarded after the call,' but this is not explained in context of the tool's purpose.

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

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

The description is a single sentence, which is concise, but it is under-specified for a tool with nine parameters and no output schema. It lacks front-loaded essential information and does not earn its brevity.

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

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

For a tool with nine optional parameters and no output schema, the description is severely incomplete. It does not explain what the output looks like, how to select the place, or any prerequisites. An agent cannot call this tool correctly based on the provided information.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds nothing to clarify which parameter is the place specifier. The schema descriptions themselves are confusing (e.g., 'city' is for a 'public weather hint'), and the tool description does not disambiguate 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 that the tool provides latitude and longitude for a place via Open-Meteo, but it does not explain how to specify the place. The input schema has nine optional parameters, none of which clearly identify a place; 'city' and 'query' are described ambiguously. This vagueness fails to distinguish the tool from siblings like weather-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?

There is no guidance on when to use this tool versus alternatives. No sibling tools are mentioned, and the description does not clarify which parameter to supply for the intended purpose. An agent would have no idea how to invoke it correctly.

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 only mentions parsing from a GitHub URL, but the schema includes 9 unrelated parameters (city, feed, json, zone, etc.) with no explanation of their role. This misrepresents the tool's actual scope and fails to disclose behavior for these parameters, especially with no annotations to compensate.

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

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

The description is a single sentence, which is concise, but it is too sparse for a tool with 9 parameters and no output schema. The brevity sacrifices necessary detail, 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 the tool's complexity (9 params, no required, no output schema, no annotations), the description is grossly incomplete. It doesn't explain the purpose of the other parameters, the return format, or error behavior, leaving agents with insufficient information to call the tool correctly.

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

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

Schema description coverage is 100%, so each parameter already has a description. The tool description adds no additional meaning beyond the schema—it doesn't even explicitly state that 'url' is the relevant parameter—but it doesn't contradict the schema either. Baseline of 3 is appropriate.

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

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

The description clearly states the tool's function with a specific verb ('Parse') and resource ('owner and repo from a GitHub URL'), which is distinct from sibling shape tools like figma-url-shape or jira-key-shape. It unambiguously identifies the target input type and expected output.

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

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

No guidance is provided on when to use this tool instead of alternatives such as normalize-url or browser-url-ok. There are no usage conditions, exclusions, or mention of alternatives, leaving the agent to infer 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 behavioral disclosure. It only states 'Titles discarded,' which is a minor detail. It does not mention side effects (read-only implied but not stated), return format, pagination, or any limitations. For a tool that likely just returns a count, the lack of detail is a significant gap.

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

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

The description is very short (two sentences) and the main purpose is front-loaded. It is appropriately sized for a simple counting tool, with no filler. However, the brevity comes at the cost of completeness.

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

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

The tool has 9 parameters, no output schema, and no annotations. The description is severely incomplete: it does not specify which parameter is used, what the return value looks like (e.g., a number, a count of items), or any usage context. An agent would be hard-pressed to invoke this correctly without external knowledge. This is inadequate for a tool with this complexity.

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

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

Schema description coverage is 100%, so baseline is 3, but the description does not clarify which of the 9 parameters are actually relevant to counting HN stories. The parameters seem generic and unrelated (e.g., 'city', 'zone', 'json'), and the tool description gives no hint of which parameter to use. This is confusing and the description adds no value beyond the schema.

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

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

The description states a specific action (count) and a specific resource (Hacker News front-page stories). It is clear and unambiguous, though it doesn't explicitly contrast with sibling tools. The phrase 'Titles discarded' adds a small but relevant detail about 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 given about when to use this tool versus alternatives like 'fetch-status' or 'web-fetch'. There is no mention of prerequisites, context, or exclusion criteria. The description is purely functional with no usage context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Common IANA timezone names for clock calls' which does not describe what the tool does with its 9 input parameters or what it returns. No side effects, safety profile, or return format are mentioned. The mismatch between the timezone-focused description and the broad parameter list (url, city, feed, json, etc.) is not explained.

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

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

The description is extremely short (one sentence), which is concise, but it lacks substantive content. It is not front-loaded with key information; it states a vague purpose without any operational detail. While brevity is good, it sacrifices usefulness.

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 tool with 9 parameters, no output schema, and no annotations. The description provides almost no context about the tool's purpose, behavior, or expected output. It is severely inadequate for an agent to call it correctly, especially given the puzzling parameter list that includes unrelated fields like 'url' and 'json'.

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

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

Schema description coverage is 100%, so all parameters have descriptions in the schema itself. The tool description adds no extra parameter semantics. Baseline is 3 because the schema already provides meaning, even though the parameter list seems incongruent with the timezone-focused description.

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

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

The description is a noun phrase ('Common IANA timezone names for clock calls') with no explicit verb or action. It identifies a resource (IANA timezone names) but does not state whether the tool returns, validates, lists, or otherwise processes them. This is vague and does not distinguish it from siblings like 'timezone' or 'utc-time' that also relate to timezones.

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 reference any sibling tools or conditions for selection. An agent is left to guess whether this is a lookup, a validation helper, or something else.

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

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

With no annotations, the description must carry the behavioral burden, but it only states that it fetches robots.txt and returns group counts. It does not disclose network behavior, error handling, how the URL is derived from parameters, or what 'group counts' means. The parameter descriptions suggest unrelated discards, adding confusion.

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

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

The description is a single concise sentence with no fluff, front-loaded with the action. It earns a high score for efficiency, though the extreme brevity contributes to the lack of behavioral 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?

For a tool with 9 parameters, no output schema, and no annotations, the description is grossly insufficient. It fails to explain how parameters map to the robots.txt fetching, the return format, error conditions, or any operational details, making it nearly impossible for an agent to call 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 individual parameter descriptions, but they are unrelated to robots.txt (e.g., 'Git ref name; discarded after the shape check'). The tool description does not connect any parameter to the robots.txt URL, so it adds no value and the schema itself is 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 a specific verb and resource: fetch a public robots.txt and return group counts. This distinguishes it from generic fetch tools like web-fetch. However, it does not explicitly contrast with siblings or mention the output format, so it falls short of a perfect 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?

No guidance is given on when to use this tool versus alternatives like web-fetch or fetch-status. The description does not state any preconditions, use cases, or exclusions, leaving the agent to infer appropriate usage.

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

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

With no annotations, the description carries the burden of disclosing side effects. It says 'Key discarded,' which hints at not retaining input, but it does not explicitly state that the operation is read-only, side-effect-free, or what happens on invalid input.

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 brief and to the point, using only two sentences. However, 'Key discarded' adds little clarity and could be replaced with more useful information.

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

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

The tool context is incomplete: the description and schema are severely misaligned, no output schema is provided, and there is no indication of how the Jira key should be supplied. An agent cannot reliably call this tool correctly based on the provided information.

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

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

The schema lists nine parameters, but none is named 'key,' and the descriptions appear unrelated to Jira issue keys (e.g., 'Git ref name,' 'City name for a public weather hint'). The tool description mentions a key, but no parameter is identified as the key input, making it impossible to know which field to populate.

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 and object: 'Check a Jira issue key shape.' This is clear enough to distinguish the tool's core purpose from most siblings. However, the phrase 'Key discarded' is ambiguous and does not clarify whether this is a validation-only operation or something else.

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

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

The description provides no guidance on when to use this tool versus alternatives such as domain-shape, github-repo-shape, or normalize-url. It does not mention any preconditions, expected input format, or exclusions.

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

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

The description reveals that the body is discarded, but says nothing about side effects, response format, error behavior, or what happens if multiple parameters are supplied. With no annotations, more behavioral disclosure is needed.

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

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

The description is short and front-loaded, but it is too terse for a 9-parameter tool and contains no structured usage details. It earns a middle score for brevity without sacrificing needed 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?

Despite a complex 9-parameter optional schema and no output schema, the definition provides only a single sentence and no examples. It is not nearly complete enough for an agent to invoke the tool correctly.

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

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

Each parameter has a brief description, but they do not cohere with the stated tool purpose and no guidance is given for choosing among them. The 100% schema coverage cannot compensate for the lack of connection to the tool behavior.

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

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

The description states one narrow behavior (HTTP status for a public library docs URL), but the schema exposes 9 unrelated optional parameters, so the tool's actual purpose is not clear. It is not a tautology, but it does not accurately scope what the tool can do.

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 for when to choose this tool over sibling tools like fetch-status or web-fetch, nor which parameter to supply. With 9 optional parameters, this is a serious omission.

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

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

No annotations are provided, so the description bears the full burden. It discloses only that values are discarded, but omits details such as whether the JSON is validated, what the return value looks like, or how invalid input is handled.

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, concise and direct. It avoids unnecessary verbosity, though it lacks contextual 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?

With 9 parameters, no output schema, and no annotations, the description is far from complete. It does not explain the return format, how other parameters are used, or when this tool is appropriate.

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 brief description, so the baseline is 3. The tool description adds no additional meaning about how parameters relate to counting keys; the 'json' parameter is not explicitly identified as the primary input.

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

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

The description states a clear action: 'Count keys in a JSON object.' It also specifies that values are discarded, which clarifies scope. However, it does not distinguish itself from sibling tools like 'validate-json' or 'search-query-len'.

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

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

No guidance is provided on when to use this tool versus alternatives. The description offers no conditions, exclusions, or comparisons to 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?

The description discloses the main output and that query/fragment are dropped, but it does not explain behavior for invalid URLs, missing parameters, or the many unrelated schema fields. With no annotations, this partial transparency 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 itself is concise and front-loaded, using one clear sentence. However, the overall tool definition is structurally muddled by the oversized, unrelated parameter list.

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 gives the output shape but omits how inputs are expected, what happens with invalid URLs, and why so many unrelated parameters exist. With no output schema, the description is not fully self-sufficient for an agent.

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

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

The schema contains nine optional parameters, but most are unrelated to URL normalization (e.g., 'ref', 'city', 'feed', 'json', 'zone', 'query') and appear copied from other tools. Only 'url' aligns with the description, and the others add confusion rather than semantic clarity.

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

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

The description clearly states the tool returns origin, host, and path from a URL and drops query and fragment. It is specific and understandable, though it does not mention the parameter name or distinguish itself from sibling URL 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 provided about when to use this tool versus alternatives such as web-fetch, browser-url-ok, or fetch-status. There is no mention of appropriate scenarios, prerequisites, or edge cases.

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 does state 'No browser is launched,' which is a small behavioral detail, but it omits what the tool actually does (e.g., validation, normalization, or status checking), return values, side effects, or permissions. For a tool with 9 heterogeneous parameters, this is grossly 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 short (two sentences) and front-loaded, but it is under-specified for a tool with 9 parameters and no other structured info. Conciseness is not a substitute for essential information; this borders on cryptic, not concise.

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

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

Given the complexity (9 parameters, no output schema, no annotations), the description is completely inadequate. It does not explain what the tool does with each parameter, when to use it, what the result looks like, or how it relates to the many siblings. Almost everything an agent needs is missing.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. However, the tool description claims it checks a URL, yet most parameters (city, zone, json, path, query) are not URLs. This misleads an agent about which parameters are relevant. The description adds no value beyond the schema and actually obscures parameter selection.

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

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

The description says 'Check whether a URL can be opened,' which is a verb+resource but is vague and incomplete. The tool accepts 9 diverse parameters (city, zone, json, path, etc.) that are not URLs, so the stated purpose misrepresents the actual scope. It also fails to differentiate from siblings like browser-url-ok or normalize-url.

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

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

There is no guidance on when to use this tool versus alternatives. No mention of conditions, exclusions, or comparisons to sibling tools like browser-url-ok, web-fetch, or normalize-url. An agent gets zero help choosing 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 or description of side effects, return format, or error behavior; it is unclear what the tool does with the provided parameters and whether it is a read-only operation.

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

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

The description is very short, but it lacks a verb and is more a label than a sentence; it is concise but not structured to explain usage.

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

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

The tool has nine irrelevant parameters and no output schema; the description gives no information on how to invoke it correctly, so an agent would not know what to pass or expect in return.

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

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

Although the schema descriptions cover each parameter, they are generic (URL, city, JSON, etc.) and appear unrelated to unit conversion; the tool description provides no mapping or clarification for any parameter.

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

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

The description 'PSI to kilopascals' identifies the conversion but uses a noun phrase rather than an explicit verb, and the schema provides no numeric input, making the practical purpose ambiguous.

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

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

No guidance is given on when to use this tool versus alternatives like calc-eval; no mention of appropriate inputs or conditions is made.

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 does state that the query is discarded, which is a useful transparency note. However, it does not disclose what happens to the other parameters (some are described in the schema as discarded, but the description itself does not mention them), nor does it describe the return value or any side effects. The single disclosure is partial.

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

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

The description is extremely short (two sentences), but this is under-specification rather than effective conciseness. It front-loads the main action, but leaves out essential context about the other parameters and the return value. Every sentence earns its place, but there is simply not enough content to be well-structured.

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

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

For a tool with 9 parameters and no output schema, the description is severely incomplete. It does not explain why the tool accepts many unrelated parameters, what happens if multiple are provided, or what the output format is. An agent cannot reliably know how to invoke the tool correctly, especially given the lack of usage guidance and return type information.

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

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

The schema provides descriptions for all 9 parameters (100% coverage), so the baseline is 3. The tool description does not add any meaning beyond the schema; it only mentions 'query' without elaborating on its format or behavior. Since the schema already covers each parameter, the description adds no extra semantic value.

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

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

The description clearly states the core action: count characters in a search query. It specifies a verb and resource, which is unambiguous. However, it does not differentiate from sibling count tools like memory-key-count or hn-front-count, and it does not explain why the schema contains 8 other parameters, so the purpose is only partially clarified.

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, nor any mention of conditions or exclusions. The description says nothing about the intended use case or why the other parameters exist. An agent would have no idea whether to call this tool over others for query length checks.

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 implies a read-only catalog but does not disclose side effects, output format, or the fact that all nine parameters appear to be ignored or discarded.

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

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

The description is extremely concise and front-loaded, using a single clear sentence with no fluff or redundancy.

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

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

The description lacks important context: there is no output schema, no explanation of what the catalog contains beyond 'common' status codes, and no reconciliation with the confusing set of optional parameters. An agent would be uncertain about the expected return value and whether parameters matter.

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

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

Although the schema has 100% description coverage, the parameter descriptions are unrelated to a status-code catalog and appear copied from other tools, with notes like 'discarded after the shape check.' This adds confusion rather than clarifying how each parameter relates 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 clearly identifies the tool's purpose: providing a short catalog of common HTTP status codes. It distinguishes the tool from siblings like fetch-status by focusing on a static catalog rather than fetching or checking a URL, though it does not explicitly state that it returns a list.

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

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

There is no guidance about when to use this tool versus alternatives such as fetch-status or web-fetch. The description does not mention scenarios, expected input, or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only mentions 'Prompt discarded,' giving no information about parameter handling, side effects, network access, or read-only nature. The schema descriptions hint at discarding inputs, but the tool description itself provides no 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 a single sentence, but it is under-specified rather than concise. It fails to convey essential information about inputs, outputs, or behavior, making it more of a stub than an efficient summary.

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

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

For a tool with 9 parameters, no output schema, and no annotations, the description is grossly incomplete. It does not explain what the tool actually does with its inputs, what the 'three-step thinking template' is, or why an agent would invoke it. The context signals reveal high complexity, but the description provides almost no coverage.

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

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

Schema description coverage is 100%, so the schema already documents each parameter's purpose. The tool description adds nothing about parameters, but the baseline of 3 applies because the schema handles the semantics adequately, even though the descriptions are somewhat cryptic.

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

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

The description states a verb and object ('Return a three-step thinking template') but is extremely vague about what the tool is for and how it relates to its 28 siblings. It does not distinguish itself from similar shape-check or utility tools, and the purpose remains unclear beyond returning a template.

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 gives no context, exclusions, or references to sibling tools. An agent would have no idea why to select this over, say, 'validate-json' or 'calc-eval'.

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

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

With no annotations provided, the description carries full responsibility for disclosing behavior. It fails to mention that the schema accepts many unrelated parameters and what the tool does with them (e.g., discarding them), nor does it clarify if any side effects or network calls occur. The description's narrow focus contradicts the schema's breadth, leaving significant behavioral ambiguity.

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

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

The description is a single sentence, which is concise, but it is under-specified. It omits critical information about parameter usage and the tool's broader behavior, making it an insufficient specification rather than a properly sized concise description. The brevity does not serve the agent's needs given the tool's complexity.

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

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

For a tool with 9 parameters, no output schema, and no annotations, the description is woefully incomplete. It does not explain the purpose of the other parameters, how it relates to sibling tools, or what the return value looks like. An agent cannot reliably determine how to invoke this tool correctly based on the description alone.

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

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

Although the schema provides 100% coverage with descriptions for all 9 parameters, the tool description adds no value beyond what the schema states. It does not clarify that only the 'zone' parameter is relevant, nor does it explain the purpose of the other parameters. The description could have explicitly indicated that other parameters are ignored or used for different checks, but it does not, leaving the agent confused about which parameter to provide.

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

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

The description clearly states the primary function: returning the current time in an IANA timezone. However, it does not differentiate from sibling tools like 'utc-time' or 'iana-zones', and the input schema includes 8 other unrelated parameters (ref, url, city, feed, etc.) with no explanation of why they exist, creating ambiguity about the tool's actual scope.

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

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

The description offers no guidance on when to use this tool versus alternatives such as 'utc-time' for UTC time or 'iana-zones' for listing zones. There is no mention of conditions, exclusions, or preferred use cases, leaving the agent without any decision support.

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 simply says 'Current UTC timestamp' but fails to mention that all nine parameters are accepted and discarded. This is a significant hidden behavior that could mislead an agent into thinking the tool processes those inputs. The schema descriptions hint at discarding, but the tool description itself does not.

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

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

The description is a single, focused sentence with no fluff. It is front-loaded with the core purpose. This is exemplary conciseness, though it may be too minimal given the tool's complexity.

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

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

The tool has 9 parameters but no required ones, and the description does not explain why they exist or that they are ignored. It also does not specify the output format (e.g., ISO 8601, Unix epoch). Given the simplicity of the tool, this is incomplete—an agent might wonder whether to pass a parameter and what the returned timestamp looks like.

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

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

The input schema has 100% coverage, with each parameter described (e.g., 'discarded after the shape check', 'no disk access'). The tool description adds no additional meaning about parameters, so the baseline of 3 is appropriate. However, the parameter descriptions themselves are informative enough for an agent to understand they are not used for time computation.

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 a clear and specific purpose. It distinguishes from the sibling 'timezone' (which likely converts times) and 'iana-zones' (which lists zones). However, it does not explicitly mention that all input parameters are ignored, which could confuse an agent about the tool's actual scope.

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

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

There is no guidance on when to use this tool versus alternatives like 'timezone' or 'iana-zones'. The description does not mention prerequisites, limitations, or use cases. An agent would have no idea whether to call this for time conversion or zone listing.

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 explaining behavior. It does disclose that the body is discarded, which implies no persistence, but it does not state whether the tool returns a boolean, throws an error, handles malformed input, or what 'valid JSON' means in terms of schema strictness.

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 no filler or redundant wording. The single sentence is easy to parse, though it sacrifices important detail for brevity.

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

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

The tool is incomplete in context: there is no output schema, no annotations, no required parameters, and no explanation of the return value or error semantics. The mismatch between 'body' in the description and the diverse optional schema properties leaves significant gaps for an agent trying to invoke it correctly.

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

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

The schema properties have individual descriptions and 100% coverage, but most are irrelevant to JSON validation (e.g., 'url', 'city', 'feed', 'zone', 'query'). The 'json' property is the only clearly relevant one, yet the description says 'body' rather than mapping to that parameter, leaving the agent to guess which properties actually 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 states the core action—'Check whether a body is valid JSON'—with a specific verb and resource, so the general purpose is clear. However, it refers to 'body' while the input schema exposes a 'json' property, creating ambiguity about what exactly should be passed.

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

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

The description gives no guidance on when to use this tool instead of the many sibling tools, nor does it mention any prerequisites or typical usage. It only states what it checks, with no context about when validation is appropriate or what alternatives might apply.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states the core function and fails to mention that the other 8 parameters in the schema are discarded (as their descriptions indicate), that the tool is read-only, or what happens when the city is not found. This lack of transparency could mislead an agent into passing unrelated parameters expecting them to have effect.

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

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

The description is extremely short, but it is under-specified rather than concise. It omits critical information about the tool's scope and parameter handling. The single sentence does not earn its place because it fails to convey the tool's full behavior and leaves the agent to infer from the schema.

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

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

Given the tool's complexity (9 parameters, no annotations, no output schema), this description is grossly incomplete. It explains only one use case (city temperature) and provides no information about return format, error handling, or the purpose of the other parameters. An agent cannot reliably invoke this tool correctly based on the description alone.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds no extra meaning about parameters beyond what the schema already provides; it only implicitly mentions 'city' in the purpose. It neither clarifies nor contradicts the schema, so a 3 is appropriate.

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

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

The description states a clear verb and resource: 'Current temperature for a city' with a specific data source (Open-Meteo). It is unambiguous about the core function but does not differentiate from siblings like geo-hint, which might also be location-related. No sibling comparison is given.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention any exclusions, prerequisites, or conditions that would help an agent decide between weather-hint and other tools such as geo-hint or fetch-status.

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

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

With no annotations, the description must carry the full behavioral burden. It discloses that the body is discarded but says nothing about how the many other parameters are handled or whether the operation is read-only. The mismatch between the description's narrow focus on URLs and the schema's broad parameter set creates ambiguity.

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

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

The description is a single sentence, front-loaded with the core action, and contains no filler. It earns a high score for efficiency, though it sacrifices completeness for brevity.

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

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

The tool has nine parameters, no output schema, and no annotations, yet the description only addresses the URL case. It fails to explain the role of the other parameters or the tool's behavior in non-URL scenarios, leaving the agent without sufficient context to use it correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no extra meaning beyond the schema for any parameter, including 'url', and does not clarify the purpose of the other eight parameters. It neither enriches nor contradicts the schema, so a baseline score 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 verb ('fetch') and resource ('public URL'), and notes the body is discarded, which is a useful differentiator. However, the tool's schema includes nine unrelated parameters (city, zone, query, etc.) that are not mentioned, making the stated purpose misleading about the tool's actual scope.

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

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

The description gives no guidance on when to use this tool versus siblings like fetch-status or browser-url-ok. There is no mention of alternatives, exclusions, or preferred contexts, 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?

The only behavioral detail is 'Title discarded after the call,' indicating no persistence. There is no mention of side effects, read-only nature, rate limits, or error behavior. Given the lack of annotations, the description carries the full burden but provides minimal 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 a single sentence, extremely concise and free of unnecessary information. It conveys the core action and a notable behavioral detail without redundancy.

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

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

The tool is simple but the description leaves critical gaps: it does not clarify which parameter holds the Wikipedia title, does not describe the output or return format, and does not mention any constraints or edge cases. The mismatch between the description and schema makes it incomplete for an agent to invoke 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 parameter descriptions are generic and misleading. They reference unrelated concepts (e.g., 'Git ref name,' 'HTTPS URL,' 'City name') and do not map to the tool's purpose of checking a Wikipedia title. No parameter is clearly identified as the title input, making the schema semantically disconnected from the description.

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

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

The description clearly states the tool's purpose: 'Check whether a Wikipedia title exists.' It uses a specific verb and resource, and the discard note adds a behavioral hint. However, the schema does not align with this purpose, which slightly reduces clarity (but the description itself 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 does not provide any guidance on when to use this tool versus alternatives. There is no mention of conditions, typical scenarios, or when not to use it. It only states what it does, leaving the agent to infer usage.

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