Tool catalog size

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

With no annotations, the description carries the full burden for behavioral disclosure, but it only states that no browser is launched. It does not mention network requests, potential side effects, error behavior, timeouts, or whether the result is a boolean status or something else.

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 main description is a short, front-loaded sentence, but it is too sparse to be useful. The large, unrelated parameter list adds noise rather than structure, and the description does not earn its place by clarifying the tool's real 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?

The tool has no output schema, no annotations, and a vague one-line description. It does not explain what the tool returns (e.g., boolean, status code, error), how to supply the URL, or why nine arbitrary optional parameters exist. This is far from enough context for an agent to use the tool correctly.

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

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

Although every parameter has a schema description, the descriptions are largely incoherent for a URL-openability check. For example, 'url' is described as 'HTTPS URL to normalize or cite,' and parameters like 'city,' 'feed,' and 'zone' are irrelevant to the stated purpose. The repeated 'discarded after...' notes also suggest that most inputs are ignored, contradicting the impression that they are meaningful inputs.

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

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

The description states a verb and resource ('Check whether a URL can be opened') but is ambiguous: it does not explain how openability is determined without launching a browser, and the tool name suggests browser behavior that the description explicitly denies. It also does not distinguish this from sibling tools like fetch-status, playwright-url-ok, 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?

There is no guidance on when to use this tool instead of alternatives such as fetch-status, normalize-url, or playwright-url-ok. The only behavioral hint, 'No browser is launched,' is not framed as a usage condition or selection 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses only that the expression is discarded, but fails to state whether the evaluation result is returned, what side effects occur, or how failures are reported. The combination of 'Evaluate' and 'discarded' is internally ambiguous.

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 two sentences are short and front-loaded, but they are drastically under-sized for a nine-parameter tool with no annotations or output schema. The brevity reads as under-specification rather than efficient conciseness because critical information is absent.

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

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

With nine parameters, no annotations, and no output schema, a complete description would need to identify the expression parameter, supported syntax, return behavior, and relationship to sibling tools. The description provides none of this, so an agent cannot reliably select or 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 baseline would be 3, but the description adds no mapping to any actual schema parameter. It references an 'expression' that does not exist among the provided parameters, which actively confuses agents rather than clarifying how to invoke the tool.

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 clear operation, 'evaluate a+b style arithmetic', but the input schema exposes only unrelated string parameters such as ref, url, city, feed, host, json, path, and query, with no expression parameter. The phrase 'Expression discarded' also muddles whether a result is returned, making the stated purpose misleading in practice.

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 use this tool versus siblings like validate-json, search-query-len, or normalize-url. The only additional sentence, 'Expression discarded', is a behavioral note rather than usage direction, and no alternatives or exclusions 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?

With no annotations, the description carries the full burden of behavioral disclosure. 'Tool catalog size' reveals nothing about side effects, return values, safety, or special behaviors. The presence of unrelated parameters (url, host, json, zone) is unexplained, and the description does not clarify whether this tool lists, counts, validates, or modifies anything.

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

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

The description is extremely short with no wasted words, but this is under-specification rather than effective conciseness. It fails to provide enough context to be useful, so the structure earns no credit for front-loading meaningful content.

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

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

Given 4 parameters, no required fields, no output schema, and no annotations, the description is grossly insufficient. An agent cannot determine what this tool does, how the parameters should be used, or what result to expect. Several siblings perform more clearly defined functions, making this tool's purpose even more opaque.

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

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

Schema description coverage is 100%, so each parameter has an individual description and the baseline is 3. However, the tool description adds no parameter semantics and does not explain how 'url', 'host', 'json', or 'zone' relate to 'tool catalog size'. The schema descriptions themselves are clear, but the overall parameter-tool mapping is confusing.

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

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

The description 'Tool catalog size' conveys that the tool relates to the size of a tool catalog, giving a vague sense of its purpose. However, it lacks a clear verb or resource and does not differentiate it from sibling tools such as status-catalog or iana-zones. It is more than a pure tautology because 'size' adds a specific output attribute, but it remains 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?

There is no guidance on when to use this tool versus alternatives. The description does not mention any scenario, prerequisite, or exclusion. The sibling list suggests this may be a catalog utility, but nothing tells an agent when this tool is appropriate.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It usefully notes that page content is not stored, but it does not mention network behavior, side effects, permissions, or how the json and zone inputs behave, leaving important execution details 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?

The description is two clear, front-loaded sentences with no wasted words. The storage disclaimer adds value, though the description is slightly under-specified given the broader input 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?

The description is incomplete for a tool with four optional parameters and no output schema. It explains only the URL-related function and leaves json and zone parameters unexplained in the description, while the lack of annotations requires more return-format and behavior 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?

Schema description coverage is 100%, so the baseline is 3. The description adds minor meaning by tying url to host, scheme, and HTTP status outputs, but it provides no additional semantics for host, json, or zone beyond the schema descriptions.

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

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

The description clearly states that the tool returns host, scheme, and HTTP status for a URL, which is a specific action. However, it does not differentiate from siblings like normalize-url or status-catalog, and it ignores the json and zone parameters present in 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 given about when to use this tool instead of related siblings such as normalize-url, status-catalog, or validate-json. The URL-metadata use case is implied, but no alternatives or exclusions 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?

With no annotations, the description carries the behavioral disclosure burden. It does add one meaningful behavioral trait, 'No identifiers are retained,' which gives a privacy guarantee. However, it does not clarify whether the operation is read-only, whether other data is stored, or what side effects might occur.

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

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

The description is very short and front-loads the primary action in the first sentence; the second sentence adds a privacy note. Both sentences are purposeful, though the brevity contributes to the overall vagueness.

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 four optional parameters, no required fields, no output schema, and no annotations, so the description must compensate by clarifying invocation and return expectations. It does neither: the agent cannot tell whether to pass one parameter or several, what 'classified' means, or what response will look 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?

Schema description coverage is 100%, so the parameters themselves are independently documented. The tool description adds no additional meaning about how url, host, json, or zone relate to the classification behavior, 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 uses a clear verb ('Show') but the object is vague: 'how this request is classified' does not explain what classification means, what output is produced, or how it relates to the tool's 'compatibility' name. It also provides no differentiation from sibling tools like normalize-url or validate-json.

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 validate-json, normalize-url, or timezone. The description gives no context about which input to provide or what situation calls for this tool, leaving the agent to guess.

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

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

With no annotations, the description carries the full burden, but it only discloses the absence of WHOIS/ownership data. It does not mention output shape, whether any validation or normalization occurs, side effects, error behavior, or how the json and zone parameters are used. Minimal transparency beyond the core action.

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

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

The description is a single front-loaded sentence with no wasted words; the limiting clause 'without WHOIS or ownership data' earns its place. It is concise, though the brevity omits important operational context, so it falls just short of a perfect structure score.

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

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

For a tool with four heterogeneous parameters, no output schema, and no annotations, the one-sentence description is not complete. It does not state which parameter is canonical, what the tool returns, or how it compares to siblings like normalize-url and validate-json. An agent would struggle to invoke it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds no parameter-level meaning beyond the schema; it only references 'hostname' while the schema also includes url, json, and zone with no explanatory link. The schema does the work here.

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 ('split') and resource ('hostname'), and the phrase 'without WHOIS or ownership data' helps distinguish this tool from potential domain lookup alternatives. However, it does not reconcile the unrelated url/json/zone parameters in the schema, leaving some ambiguity about the tool's full 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 explicit guidance on when to use this tool versus siblings like normalize-url or validate-json. The only hint is the negative clause 'without WHOIS or ownership data,' which sets a boundary but does not tell an agent the preferred selection conditions.

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

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

With no annotations provided, the description must carry the burden of disclosing behavior. It mentions returning status only but does not explain that the many additional schema parameters appear to be ignored or unrelated, nor does it state that HEAD is read-only and has no side effects.

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

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

The description is a single concise sentence that front-loads the core action and result. It avoids unnecessary detail and 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?

The description is too minimal for the complex, unrelated parameter set. It does not specify the output format (e.g., HTTP status code only), whether other parameters are required or ignored, or how to handle cases where no URL is provided. This leaves an agent uncertain about how 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?

The schema descriptions are present and cover each parameter, but they are inconsistent with the tool's stated purpose. For example, the 'url' parameter is described as 'HTTPS URL to normalize or cite' rather than as the target of the HEAD request, and several parameters are described as being discarded, which is confusing for 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 clearly states the tool performs an HTTP HEAD request on a public URL and returns only the status, which is a specific action with a clear resource. This distinguishes it from sibling tools like web-fetch or normalize-url that deal with content or URL transformation.

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 explicit guidance on when to choose this tool over alternatives such as browser-url-ok or web-fetch. The use of 'HEAD' and 'status only' implies a lightweight status check, but no direct comparison or exclusion is given.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does disclose that the path is discarded, which is useful, but it does not state whether the tool returns a boolean, extracted components, a normalized URL, or an error on non-Figma URLs. The description is too thin to be behaviorally transparent.

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

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

The description is exceptionally concise, with two short sentences and no filler. The core verb and resource come first, and the key caveat 'Path discarded' is immediately front-loaded. Every word 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 no output schema, no annotations, and nine optional parameters, the description is not complete enough for correct invocation. It does not explain what the tool returns, how it handles invalid or non-Figma URLs, or which of the nine schema fields is actually relevant. An agent would struggle to call it confidently.

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

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

Although the schema has 100% description coverage, the schema descriptions are generic and poorly aligned with the tool purpose: 'url' is described as 'HTTPS URL to normalize or cite' rather than as a Figma file URL, and eight other unrelated fields such as city, feed, json, zone, and query create ambiguity. The tool description provides no mapping from 'Figma file URL' to the specific parameter an agent should supply.

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

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

The description clearly states a specific verb and resource: 'Parse a Figma file URL.' The addition 'Path discarded' further distinguishes this from generic URL tools and sibling shape tools by hinting at a unique behavior. The Figma qualifier makes it easy to tell apart from github-repo-shape, jira-key-shape, and similar 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 gives clear contextual usage: this tool is for Figma file URLs, not general URLs or other domains. It does not explicitly name alternatives or provide when-not-to-use cases, but the domain-specific phrasing is enough to route an agent among the 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 a key behavioral trait—'No disk access'—which is valuable because the tool has no annotations to cover side effects. However, it does not describe the return value, error behavior, or what 'safe' means, leaving part of the behavioral burden unaddressed.

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. The primary purpose is front-loaded, and the behavioral constraint follows immediately, making it easy for an agent to parse quickly.

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 no annotations, no output schema, and nine optional parameters, the description is too sparse to fully support correct invocation. It does not state whether any parameter is required, what the tool returns, or what safety checks are performed, so an agent may not know how to call it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3, and the 'path' parameter is appropriately described as 'File path to check.' The tool description itself does little to disambiguate which of the nine optional parameters apply to this tool, and many unrelated parameters (ref, city, feed) could mislead 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 clearly states the action ('Check whether'), the object ('a path'), and the property ('looks safe'), while adding the useful constraint 'No disk access.' It does not explicitly distinguish this from sibling tools, but the tool name and path-specific scope make the purpose unambiguous.

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

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

The description implies when to use the tool: to validate whether a path is safe without touching the filesystem. However, it gives no explicit when-not-to-use guidance, prerequisites, or alternatives, so the agent must infer usage from context and sibling names.

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

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

Annotations are absent, so the description carries the full behavioral disclosure burden. It reveals an external dependency on Open-Meteo, but it does not state whether the operation is read-only, what happens to the input, whether network failures are possible, or what the response format looks like. Some behavior is implied, but most is left undisclosed.

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

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

The description is a single short sentence with no filler, and the core output is front-loaded. It is concise and easy to scan, though its brevity contributes to the overall lack 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?

With nine optional parameters, no annotations, and no output schema, the one-line description is insufficient for reliable invocation. It does not say which parameter carries the place, what shape the latitude/longitude result takes, or whether the other parameters are ignored. The basic purpose is present, but too much essential context 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 baseline is 3 even though the description adds no parameter-level detail. The phrase 'a place' loosely suggests the city parameter, but the description does not explicitly map 'place' to any of the nine optional parameters or clarify that the other eight are irrelevant. It neither meaningfully enhances nor directly contradicts 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 names an output (latitude and longitude) and a provider (Open-Meteo), which suggests a geocoding purpose, but it lacks a verb and never explicitly says 'geocode a city' or 'return coordinates for a place'. It is somewhat distinguishable from siblings like weather-hint, but the lack of a clear action makes it only vaguely informative.

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 when-to-use guidance, no exclusion of alternatives, and no mention of when not to use this tool. The description only implies that it might be used when coordinates are needed, but it does not state this or compare against sibling tools such as weather-hint or timezone.

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 that owner and repo are parsed; it does not say whether invalid GitHub URLs error, whether unrelated fields like city or feed are ignored, whether validation occurs, or what the returned shape looks like.

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

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

The description is a single front-loaded sentence with no filler or redundancy. Every word contributes to stating the action and target resource.

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 no annotations and no output schema, yet the description does not mention return format, error handling, or which of the seven schema fields are actually consumed. The presence of unrelated fields like city, feed, and json makes the lack of additional context more problematic.

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?

Since the input schema has 100% description coverage, the baseline is 3. The description adds minimal parameter meaning beyond identifying the GitHub URL as the relevant input, but it does not compensate for or clarify the many apparently unrelated schema fields.

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 ('Parse') and resource ('a GitHub URL') and names the expected result ('owner and repo'). It is unambiguous about the core operation, though it does not explicitly contrast with sibling shape tools like figma-url-shape or jira-key-shape.

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

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

There is no guidance on when to use this tool versus alternatives such as normalize-url or browser-url-ok. No conditions, exclusions, or alternative-selection hints are provided; the intended usage is only implied by the word 'Parse'.

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 does disclose the key output trait ('Titles discarded') and implies a count-only result, but it omits return type details, network dependency, failure behavior, and whether the many optional parameters are relevant or ignored.

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

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

Two short, front-loaded sentences with no filler. Every phrase—'current', 'front-page', 'Titles discarded'—adds useful information, making this an appropriately concise definition.

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?

Without an output schema or annotations, the description leaves meaningful ambiguity: it never explains how the oversized optional input schema relates to the operation, nor specifies the return shape beyond 'count'. An agent may need to guess whether to pass parameters such as 'feed' or call with no arguments.

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

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

Schema description coverage is 100%, so the baseline is 3 even without parameter guidance. The description adds no parameter mapping and does not connect the prominent 'feed' parameter to the operation, but the schema already documents each property individually.

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 ('Count') and a precise resource ('current Hacker News front-page stories'), and 'Titles discarded' clarifies that the output is a count rather than title content. It does not explicitly distinguish this tool from any named sibling, so it stops just short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives such as web-fetch or other shape/count tools. The wording implies a count use case but provides no context, 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether the tool is read-only, what it returns, what side effects may occur, or how inputs are handled. The phrase 'Common IANA timezone names' weakly implies a static data lookup, but that is not explicit.

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, which is concise, but it is under-specified rather than efficiently complete. It provides no structural information such as return values, tool behavior, or parameter roles. The brevity comes at the cost of 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?

With four optional parameters, no output schema, no annotations, and a vague one-phrase description, the tool is not adequately characterized. It is unclear what the tool does with URL, host, JSON, and zone inputs, and how the 'common timezone names' relate to invocation. The description is far too incomplete for an agent to call this tool confidently.

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

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

The input schema already documents all four parameters at 100% coverage, so the baseline is 3. The description adds almost nothing about how parameters like url, host, json, or zone are used or related. It does not help disambiguate the unexpectedly broad parameter set.

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 rather than a verb-driven statement of what the tool does. 'Common IANA timezone names for clock calls' conveys a topic but not an operation such as 'list', 'return', or 'validate'. It adds slight context over the tool name but remains vague about the actual action.

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 sibling tools such as timezone, utc-time, or normalize-url. The phrase 'for clock calls' hints at a context, but it does not specify conditions, exclusions, or alternatives. An agent must infer when this tool is appropriate.

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

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

With no annotations, the description carries the full burden of explaining behavior, but it only states that the tool fetches a public robots.txt and returns counts. It does not disclose failure modes, whether network access is required, rate-limit implications, or what 'group counts' means, so the agent has limited insight into side effects or response shape.

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 sentence with no filler; the core verb, resource, and output restriction are front-loaded. The description is appropriately terse for a simple tool, though the ambiguity of 'group counts' is a clarity issue rather than a conciseness problem.

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?

No annotations, no output schema, and four heterogeneous parameters including seemingly irrelevant 'json' and 'zone' fields. The description does not specify which parameters are required to actually fetch a robots.txt, what 'group counts' looks like, or how errors are surfaced, so an agent cannot reliably invoke the tool on the first attempt.

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 though the description adds no per-parameter detail. However, the description does not clarify how 'json' or 'zone' relate to fetching robots.txt, and the schema descriptions for 'url' and 'host' are generic. This is a notable gap, but the high schema coverage prevents a lower score.

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 identifies a specific action ('Fetch a public robots.txt') and a specific output constraint ('return group counts only'), so an agent can understand what the tool is for and distinguish it from siblings like normalize-url or validate-json. The term 'group counts' is slightly ambiguous, but the core purpose is clear enough.

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

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

There is no guidance on when to use this tool instead of normalize-url, citation, or validate-json. The description does not mention prerequisites, typical call patterns, or exclusions, leaving the agent to infer the intended context 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, and the description only says the key is discarded. It does not disclose whether the tool returns a boolean, throws an error, or what the output format is, leaving callers unable to anticipate results.

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 one-sentence description is succinct but omits essential information. For a tool with nine optional parameters and no output schema, it is far too terse to be effective.

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 schema contains unrelated optional parameters, no required fields, and no output schema, so the description leaves critical usage details unspecified, including which parameter holds the key and what the expected result is.

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 every parameter has a description, the descriptions are unrelated to Jira issue keys (e.g., Git ref, HTTPS URL, city, JSON text, file path, timezone) and none indicate which field is the key. This is actively misleading rather than helpful.

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

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

The description states a specific action (check shape) and resource (Jira issue key), and the tool name reinforces it. However, it doesn't identify which of the nine parameters carries the key, so the purpose is clear only at a high level.

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 sibling validation or normalization tools, and there is no mention of use cases 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, the description carries the burden and does disclose the key behavioral outcome: the HTTP status is returned and the body is discarded. However, it does not clarify how the nine optional parameters behave, what happens on network or HTTP errors, or what the actual response shape 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 concise and front-loaded, with no wasted words. But it is under-specified for a tool with nine optional parameters and no annotations, so the brevity comes at the cost of necessary invocation 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?

For a tool with nine optional parameters, no annotations, and no output schema, this description is too thin. It does not say which parameter to pass, what the response format is, or how this tool differs from the many related sibling tools.

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 explicit mapping from 'public library docs URL' to the relevant parameter. The schema's own description for url ('HTTPS URL to normalize or cite') does not clearly align with the stated purpose, leaving the agent to guess 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 verb and resource: it returns an HTTP status for a public library docs URL and notes that the body is discarded. This is more than a tautology and gives some domain specificity, though it does not explicitly contrast with siblings like 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?

There is no guidance on when to use this tool versus alternatives such as fetch-status, browser-url-ok, or normalize-url. The description says what it does but not when it should be selected or what exclusions 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 burden, and 'Values discarded' is a useful behavioral disclosure indicating that input values are ignored. However, it does not say whether the count is top-level or recursive, what happens if the JSON is invalid, whether the result is persisted despite the 'memory' name, or what the return value looks like.

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. 'Count keys in a JSON object' leads with the core purpose, and 'Values discarded' adds meaningful 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?

For a tool with nine optional parameters, no output schema, and no annotations, this description is too thin. It omits how to call the tool (which parameter holds the JSON), the shape of the returned count, error behavior for invalid JSON, and the definition of 'key' (top-level vs nested), so an agent cannot reliably 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 input schema covers all 9 parameters (100% description coverage), so the baseline is 3. The description adds no extra parameter semantics beyond 'JSON object' and does not connect that to the json parameter specifically, leaving the agent to infer which of the nine string parameters is the source.

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 resource: count the keys in a JSON object, and adds that values are discarded. This is clear enough to distinguish from sibling validate-json (counting vs validating), but it does not explicitly differentiate from other counting/checking siblings or name which input parameter to use.

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 use case is implied: an agent that needs the number of keys in a JSON object should call this tool. However, there is no explicit when-to-use/when-not-to-use guidance or mention of alternatives such as validate-json for validation-only tasks, and no direction about how to supply the JSON among the nine optional parameters.

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

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

With no annotations, the description carries full burden but only reveals that query and fragment are dropped. It does not disclose how the json, host, or zone parameters behave, whether network calls are made, or what happens with invalid or non-HTTPS URLs. This is a partial disclosure with major gaps.

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

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

Two sentences contain no filler and deliver the core behavior up front. The additional detail about dropping query and fragment earns its place. The structure is efficient for what it covers.

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 four schema parameters, zero required, no output schema, and no annotations, yet the description only addresses URL normalization. It omits the purpose of host, json, and zone parameters and does not describe the return format. An agent cannot confidently decide which parameters to provide or what to expect in the result.

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

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

Although schema description coverage is 100%, the tool description conflicts with the schema by describing 'host' as a return value while the schema treats it as an input parameter. The description adds no meaning to the json or zone parameters, leaving their roles in 'normalize-url' unexplained and potentially 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 action ('Return origin, host, and path') on a specific resource ('for a URL'), which is more precise than just repeating the tool name. It implicitly distinguishes from siblings like validate-json and timezone, though it does not explicitly name any sibling or edge case.

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

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

There is no guidance on when to use this tool versus the many URL-related siblings (domain-shape, inspect-robots, citation, etc.). The note that query and fragment are dropped describes behavior, not usage context, and the presence of unrelated parameters (json, zone) with no explanation leaves the agent without 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. It discloses that no browser is launched, but says nothing about network access, side effects, return behavior, or how the many parameters are used. The behavioral contract is largely opaque.

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

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

The description is extremely short, but brevity here results in under-specification rather than conciseness. It front-loads the core idea but omits essential context, so it is not optimally 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?

A 9-parameter tool with no output schema and no annotations is severely under-described by a single sentence. The description fails to explain the purpose of most parameters or the expected output, leaving the agent unable 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 each parameter has a description. However, the tool description adds no meaning beyond the schema; many parameters (city, feed, json, path, zone, query) seem unrelated to the stated purpose, and the description does not reconcile 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?

States a specific verb 'Check' and resource 'URL', and adds the clarification 'No browser is launched' which distinguishes it from sibling browser-url-ok. However, it does not define what 'opened' means (e.g., HTTP status, accessibility), leaving some ambiguity.

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 vs alternatives. Siblings like browser-url-ok, fetch-status, normalize-url, and web-fetch overlap, but the description offers no when-to-use or when-not-to-use 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?

The description discloses that the input query is discarded, which is a useful side-effect trait given that no annotations exist. However, it does not state the return format, behavior with multiple or missing parameters, or whether any external calls are made, leaving much of the burden unmet.

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

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

Two short sentences, front-loaded with the core action, and no filler. The second sentence earns its place by disclosing that the query is discarded.

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 simple core action, the tool has nine optional parameters, no annotations, and no output schema. The description does not specify that the query parameter should be used, what the return value looks like, or what happens if no parameters are provided, so it is not complete enough for confident 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 schema already documents all nine parameters, including the query parameter as 'Search text; discarded after the length check.' The tool description adds little beyond the word 'search query' and does not clarify why the other eight optional parameters are present, so it stays at the high-coverage 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 a specific operation: count characters in a search query. 'Query discarded' adds the lifecycle of the input. It does not explicitly name the query parameter or explain how it differs from sibling tools, but the action is distinctive enough to be identifiable.

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 when-to-use guidance and no mention of alternatives among the many sibling tools. An agent must infer from the name and schema which input to supply and when this is preferable to similar validation or counting 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 of behavioral disclosure. 'Short catalog' weakly implies a read-only reference operation, but nothing is said about how the four unrelated inputs are handled, what the output looks like, or whether side effects occur.

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 under-specified rather than efficiently complete. It earns no extra credit because it conveys little beyond the tool name.

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?

A tool with four heterogeneous parameters, no output schema, and no annotations requires substantial contextual explanation. The one-line description does not explain how to invoke the catalog, what the parameters mean in this context, or what the agent should 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?

Schema coverage is 100%, so the baseline is 3. Each parameter has its own description, but the tool description adds no connection between those parameters (url, host, json, zone) and the stated purpose of listing HTTP status codes, so the parameter semantics remain confusing.

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

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

The description identifies the resource as a catalog of common HTTP status codes, which is more informative than the bare name. However, it lacks a verb such as 'returns' or 'lists' and does not differentiate it from sibling tools like catalog-tools or citation, so the purpose is only moderately clear.

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

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

No guidance is given about when to use status-catalog versus any sibling tool. The description does not state appropriate inputs, expected use cases, or exclusions, leaving the agent to guess.

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

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

The description does disclose one important behavior: 'Prompt discarded,' indicating the supplied prompt is not used in producing the template. With no annotations, the description carries the full burden, and it does not fully spell out that all parameters are effectively ignored or what the returned template contains. Still, the core non-obvious behavior is at least mentioned.

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

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

Two short sentences with the key idea front-loaded: 'Return a three-step thinking template.' There is no filler, and 'Prompt discarded' earns its place by flagging the non-obvious input behavior. The size is appropriate for the tool's simple purpose.

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

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

Even with all parameters described in the schema, the description leaves open what a 'three-step thinking template' looks like and whether any argument is needed to obtain it. Required parameters are 0 and there is no output schema, so the agent cannot infer the return shape from structured data. This is under-specified for a tool with 9 input properties and no annotations.

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

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

The input schema covers 100% of parameters with descriptions, so the baseline is 3. The tool description adds no parameter-specific meaning; at most it warns that the prompt is discarded, which is not represented as a schema property. Therefore the description does not improve on 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 action and deliverable: 'Return a three-step thinking template.' This distinguishes it from the sibling validator/calculator tools, which check URLs, paths, or formats rather than producing a template. The phrase 'three-step thinking template' is still a bit underspecified, so it does not earn 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 for when to call this tool instead of a sibling; there are no alternatives, exclusions, or conditions mentioned. 'Prompt discarded' is the only usage hint, and it tells the agent that prompt content will not matter, not when the tool should be selected. This falls below the minimum viable 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 only says 'Current time in a named IANA timezone' and does not describe output format, time source, or why url, host, and json parameters are present. It does not contradict annotations, but it is minimally transparent.

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

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

The description is a single, front-loaded sentence with no redundancy. It is concise and to the point, though its brevity contributes to missing context elsewhere.

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 no annotations and no output schema, the description is thin. An agent cannot determine which parameters are actually relevant, what the response looks like, or when to prefer this tool over time-related siblings. The unrelated schema parameters compound the incompleteness.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds little beyond aligning 'IANA timezone' with the zone parameter, and it does not explain how url, host, and json relate to the tool's purpose, leaving semantic ambiguity.

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

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

The description states the operation precisely: return the current time for a named IANA timezone. It is clearly distinct in purpose from siblings like utc-time and iana-zones, though it does not explicitly name or contrast 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 such as utc-time or iana-zones. The description also does not clarify that zone is the meaningful parameter, and the unrelated url, host, and json parameters make selection and invocation confusing.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It only states the output concept but does not describe the return format (e.g., ISO string, epoch), whether the operation is a read-only query, or why the schema includes unrelated parameters like 'url' and 'json'. The presence of parameters that are unexplained in the description creates ambiguity about the tool's 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 very short and free of fluff, which is concise. However, it is under-specified given the schema has four parameters and there are related sibling tools. It is not poorly structured, but the brevity borders on being a minimal phrase rather than a complete tool 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?

The tool lacks annotations and an output schema, and the description provides almost no context beyond the basic idea of UTC time. Given four parameters and siblings like 'timezone' and 'iana-zones', an agent cannot tell how to invoke the tool correctly, what to expect in response, or how this tool differs from related ones. This is a significant completeness gap.

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

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

The schema description coverage is 100%, so the baseline is 3. Each parameter has its own descriptive text, but the tool description adds no meaning to how these parameters relate to 'utc-time'. The parameter descriptions themselves are clear individually, yet they seem disconnected from the stated purpose, and the description does not clarify whether any are relevant.

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

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

The description 'Current UTC timestamp' clearly states the tool returns the current time in UTC. It identifies both the resource (time) and the format/zone (UTC), so an agent can infer the basic action. However, it does not differentiate from sibling tools like 'timezone' or 'iana-zones', which may overlap in purpose.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention that it should be used for obtaining the current UTC time as opposed to timezone conversion or IANA zone lookups, nor does it explain whether the provided parameters should be used or ignored.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does state that the body is discarded, which is useful, but it does not say what happens for valid vs invalid JSON, whether an error is returned, or what the response shape is. The discard fact is already present in the json parameter description.

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

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

Two short sentences with no filler; the purpose and the important discard side effect are both stated directly. Every sentence earns its place.

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

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

For a tool with no output schema and no annotations, the description is too sparse. An agent cannot tell what a successful validation returns, how invalid JSON is signaled, or what role the unrelated url, host, and zone parameters play. The singular 'body' conflicts with a four-parameter input 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 the schema already documents all four parameters. The description merely introduces the ambiguous term 'body' without explicitly mapping it to the json property or explaining why url, host, and zone are present, so 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 names a specific verb ('check') and resource ('body'/'JSON'), and it is clearly distinct from sibling tools like normalize-url and citation. However, it never explicitly identifies which input parameter is 'the body', and the schema mixes json with url, host, and zone, which slightly reduces 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?

The phrase 'The body is discarded' implies the tool is for one-off validation only and not for retention, which gives some contextual guidance. However, there is no explicit when-to-use or when-not-to-use guidance and no reference to alternative 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 transparency burden, but it only reveals that Open-Meteo is used. It does not disclose that the other parameters are discarded after various checks, that all parameters are optional, that the operation is read-only, or what the response looks like. The mismatch between the weather-focused description and the generic schema further reduces 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 sentence, front-loaded with the main purpose, and free of redundant wording. It is concise and easy to scan, though slightly too sparse given the tool's complex schema and lack of annotations.

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 no annotations, no output schema, nine optional parameters, and many sibling tools, yet the description only covers the city-temperature use case. An agent is left without guidance on which parameter to supply, what the return value is, and how this tool fits relative to siblings. This is not complete enough for confident 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. The description adds no real parameter semantics beyond pointing to 'city', and it does not clarify which of the nine optional parameters matter for the advertised weather use or how the others should be interpreted. It neither improves nor strongly harms the schema's own parameter documentation.

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

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

The description names a specific resource ('current temperature'), a target ('a city'), and a source ('Open-Meteo'), so an agent can tell the tool is about retrieving city temperature. However, it does not explicitly distinguish this from sibling hint tools, and the broad schema with eight unrelated parameters slightly weakens the 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?

The description gives no guidance on when to use this tool versus alternatives such as geo-hint or timezone. The only implicit cue is 'current temperature for a city,' which is not enough to establish selection criteria, exclusions, or preferred use 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?

With no annotations, the description carries the behavioral disclosure burden. It does disclose the primary behavior and output fields, plus the body-discard behavior. But it omits error behavior, redirects, response shape, and prerequisites beyond 'public URL', so transparency is only partially complete.

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: two short sentences, no filler, with the most important output information stated first. It is not padded, though it could be slightly expanded to cover schema ambiguity.

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 no output schema, no annotations, 9 optional parameters, and 27 sibling tools, this one-sentence description is incomplete. It does not explain the relationship to fetch-status/browser-url-ok, does not describe the output format in enough detail, and does not address why the schema contains many unrelated parameters.

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 baseline is 3, but the description does not map its behavior onto the schema. The `url` parameter is described as 'HTTPS URL to normalize or cite', not as the actual fetch target, and the other eight optional parameters are unrelated discard-only fields with no explanation of selection or precedence.

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

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

The description states a specific resource (public URL) and the returned information (HTTP status and content type), and it adds the key behavior that the body is discarded. It is clear, but it does not explicitly distinguish this tool from sibling tools 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?

The description implies the tool is for checking the status/content-type of a public URL, and 'Body discarded' is an implicit exclusion. However, it provides no explicit when-to-use guidance, no when-not-to-use conditions, and no pointers to related sibling 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 full behavioral burden. It does disclose that the title is discarded after the call, implying statelessness, and 'check whether exists' suggests a read-only operation. But it omits return type, failure behavior, network dependence, and whether matching is exact.

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. The statelessness note earns its place, and the core purpose is front-loaded. It is concise, though it sacrifices some operational detail.

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

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

Given nine optional parameters, no output schema, no annotations, and no usage guidance, the description is not complete enough for confident invocation. It fails to explain what the result means, which parameter provides the title, or how this tool relates to alternatives.

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 parameters themselves are documented, but the description adds no mapping from the core 'title' concept to any property. None of the listed parameters is identified as the Wikipedia title, making it unclear what an agent should pass. The repeated 'discarded after the call' phrasing adds no parameter-level meaning.

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

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

The description states a specific operation: checking whether a Wikipedia title exists. This is clearly distinct from generic fetch or validation tools. However, it does not explain how the title is supplied, and the schema lists no explicit 'title' parameter, so the purpose lacks an operational anchor.

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 siblings such as web-fetch, normalize-url, or validate-json. There are no preconditions, examples, or exclusions, leaving the agent to guess the appropriate context.

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