UTF-16 unit count, text discarded

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

No annotations are provided, so the description carries full burden. It states 'Returns connection methods' and 'Task text discarded', but does not disclose whether the tool makes external calls (despite 'pay-per-call' hinting at cost), what side effects exist, or how the input parameters are processed. The parameter descriptions in the schema suggest validation-only behavior, but the tool description contradicts this by implying an external gateway lookup. This lack of clarity 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 concise (two sentences) and front-loaded with the primary purpose. However, it omits crucial information about how the parameters are used, what 'connection methods' means, and how it differs from sibling tools. It is under-specified rather than efficiently concise, so a score of 3 reflects that it is brief but not adequately informative.

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

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

With no output schema and no annotations, the description is the only source of context. It fails to explain the return format (beyond 'connection methods'), how to map the 9 optional parameters to specific tasks, any prerequisites, or limitations. Given the complexity of 9 parameters and no annotations, the description is severely incomplete for an agent to call this tool correctly.

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

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

Schema description coverage is 100% and each parameter has a clear, self-contained description (e.g., 'Git ref name; discarded after the shape check', 'HTTPS URL to normalize or cite'). The tool description adds no additional meaning beyond the schema; it actually introduces a non-existent 'task text' parameter, which could confuse. Baseline 3 is appropriate since the schema does the heavy lifting, but the description fails to bridge parameters to the tool's stated purpose.

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

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

The description clearly states a specific verb ('Find') and resource ('public pay-per-call tool gateway') for tasks like weather, search, scrape, or voice. It is distinct from sibling tools which appear to be specific checks/hints. However, it does not explain how the parameters relate to this purpose, leaving some ambiguity about what the tool actually does.

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

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

No explicit guidance on when to use this tool vs alternatives. It implies a use case (finding a gateway for a task) but does not mention when not to use it, which sibling tools are alternatives, or how the optional parameters should be provided for different tasks. The mention 'Task text discarded' adds confusion rather than 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?

Annotations are absent, so the description carries the full burden. It only notes 'No browser is launched,' but omits that many parameters are discarded, that it performs shape checks on diverse inputs, and what the tool returns. This is minimal and incomplete behavioral disclosure.

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, but it is under-specified and fails to convey the tool's actual scope. It is short but not effectively structured because it omits critical information about the multi-input nature.

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 inadequate. It does not explain the tool's true purpose (shape validation across many types), the handling of each input, or the return value. An agent cannot correctly invoke it based on this description.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter information beyond the schema, which itself has per-parameter descriptions. However, the description does not help clarify why non-URL parameters exist, so it does not improve comprehension.

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 vague about what 'can be opened' means (format vs reachability) and does not match the schema, which accepts 9 unrelated parameters (city, zone, json, path, etc.). It fails to distinguish from siblings like normalize-url or fetch-status, and the mismatch makes the purpose misleading.

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

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

No guidance is given on when to use this tool versus alternatives. The description does not mention that it handles non-URL inputs, nor does it explain when to prefer this over sibling tools that check URL shape or reachability. An agent has no basis for selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Expression discarded', which is irrelevant because no expression parameter exists in the schema. It discloses nothing about side effects, permissions, error behavior, or return format. The description is essentially non-informative and mismatched with the actual tool contract.

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

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

The description is a single short sentence, which is concise in length but severely under-specified. It fails to convey any useful information about the tool's operation or parameters, so this is under-specification rather than genuine conciseness.

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

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

With 9 parameters, no output schema, and no annotations, the description must explain how the parameters relate to the stated purpose. It does not, making the tool impossible to call correctly. The description is completely inadequate for the tool's complexity.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters with individual descriptions. The tool description adds no additional meaning beyond the schema, so the baseline of 3 applies. No contradictions or extra insight are 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 states a clear verb and resource ('Evaluate a+b style arithmetic') but it does not align with the input schema, which contains no arithmetic expression parameter. This creates confusion about what the tool actually does and how it relates to its parameters. It also fails to distinguish it from any of the 27 sibling tools, many of which could plausibly handle arithmetic.

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, nor are there any exclusions, prerequisites, or context hints. The description offers no help in selecting this tool over its many siblings.

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

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

The description discloses that page content is not stored, which is a useful privacy-related behavior. However, it does not mention network effects, redirects, error behavior, or how the many discarded parameters are handled beyond their individual schema descriptions.

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 easy to read, using only one sentence to convey the core behavior. It loses some points because it omits any mention of the other parameters, but the text itself is well-structured and not verbose.

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

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

The description is far too incomplete for a tool with 9 parameters, no output schema, and no annotations. It explains only a single URL-related behavior and leaves the purpose of the other parameters, expected output structure, and error semantics entirely unaddressed.

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 individual schema descriptions, so parameter-level meaning exists. However, the tool description only references the URL parameter and gives no indication of why city, json, path, zone, and query exist, creating a significant mismatch between the described purpose and the full 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 states a specific action and output: 'Return host, scheme, and HTTP status for a URL.' However, the tool name 'citation' and the presence of 9 unrelated parameters (city, json, path, zone, etc.) make the overall purpose confusing and not fully aligned with the description.

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. Sibling tools like fetch-status, normalize-url, and web-fetch overlap directly with the described behavior, but the description gives no differentiation or 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?

The description and parameter annotations state that identifiers are not retained and data is 'discarded' or 'no disk access', which partially discloses non-persistence. However, it does not explain what the tool actually does with the inputs, so the behavioral impact remains unclear.

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 brief and lacks substance. While short and to the point, it omits critical information, making it ineffective despite its conciseness.

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

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

With 9 parameters and no output schema, the description is drastically incomplete. It does not explain what the tool returns, how the parameters relate, or what 'compatibility' refers to. The context is wholly insufficient for an agent to use it correctly.

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

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

While each of the 9 parameters has a description, the descriptions are inconsistent and do not form a coherent picture (e.g., 'public weather hint', 'titles discarded'). They hint at checking shapes or lengths but never explain the overall purpose, so the 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 'Show how this request is classified' is vague and does not explain what 'compatibility' means or what specific action the tool performs. It lacks a clear verb-resource relationship, making it impossible to distinguish from other 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 on when to use this tool versus any of the 26 sibling tools. There is no mention of conditions, alternatives, or typical 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?

No annotations are present, so the description carries the full burden. It does disclose some behavioral traits, such as not including WHOIS/ownership data, discarding certain parameters, and no disk access, but it leaves out return behavior, error cases, and potential network 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, front-loaded sentence with no filler. Every word contributes distinct meaning, and the parameter descriptions are reasonably compact.

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

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

There is no output schema, no annotations, no examples, and no error behavior. The description also fails to identify which optional parameter is the primary input or what the returned labels look like, leaving important operational context 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?

All 9 parameters have schema descriptions, which meets the high-coverage baseline. However, the tool-level description does not connect most parameters to the stated hostname-splitting purpose; only 'host' is clearly relevant, while the others are described as discarded or unrelated.

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: 'Split a hostname into labels' and distinguishes itself by explicitly excluding WHOIS/ownership data. It is recognizable among sibling URL and shape tools, though it does not name 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 sibling tools such as normalize-url, figma-url-shape, or github-repo-shape. The phrase 'without WHOIS or ownership data' is a negative scope, not an actionable usage recommendation.

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. The description says it HEADs a public URL, but the schema contains nine unrelated parameters (ref, city, feed, json, path, zone, query) whose descriptions reference other tools ('discarded after shape check', 'weather hint', 'validate', etc.). The description does not disclose that only 'url' is meaningful or that all other parameters are ignored, making actual behavior highly 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, short sentence that is front-loaded with the core action and output. It contains no fluff or redundant wording, earning every word.

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 a polluted input schema, the description is incomplete. It does not clarify that 'url' is the required parameter, that all other parameters are ignored, or what 'status only' means in terms of the return value (e.g., HTTP status code, reason phrase). This creates significant ambiguity for an agent trying 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 every parameter has a description, those descriptions are inconsistent with the tool's stated purpose. For example, 'url' is described as 'HTTPS URL to normalize or cite' rather than the target of a HEAD request, and parameters like 'city' and 'zone' reference weather/timezone hints. The schema gives no indication of which parameters are actually used or required.

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: 'HEAD a public URL and return status only.' This clearly distinguishes it from siblings like web-fetch (which retrieves content) and status-catalog (which lists statuses). The 'status only' output is a crisp, unambiguous 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?

The description does not explicitly explain when to use this tool versus alternatives such as browser-url-ok, normalize-url, or web-fetch. It implies use for lightweight status checks, but it never names sibling tools or conditions like 'use this when you only need the HTTP status code.'

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 all behavioral traits. It states that the path is discarded, which is a behavioral detail, but it omits any mention of side effects (e.g., network access, read-only nature), what happens to other parts of the URL, or whether the tool returns a result. Given the parameter list includes many unrelated fields (city, feed, host, etc.) that are said to be discarded, the description is not transparent about the overall behavior beyond the path.

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 of seven words, with no wasted text. It front-loads the core action ('Parse a Figma file URL') and immediately adds the key constraint ('Path discarded'). This is efficient and easy to scan.

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 provides almost no context for how to invoke it correctly: it does not indicate which parameter is the URL to parse, how the other parameters relate to the operation, what the tool returns, or any error conditions. The mismatch between the narrow Figma-URL focus and the broad, unrelated parameter set is confusing and leaves the agent without sufficient guidance.

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 individually described, so the schema already documents all 9 parameters. The tool description adds no additional meaning to these parameters, nor does it clarify which parameters are relevant to the Figma URL parsing. With complete schema coverage, a baseline of 3 is appropriate; the description does not degrade or enhance parameter understanding.

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

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

The description uses a specific verb ('Parse') and resource ('Figma file URL'), and notes the path is discarded. This clearly identifies the tool's core function and differentiates it from siblings like 'normalize-url' or 'domain-shape' which target different URL concerns. However, it does not specify what the tool returns or whether it validates, so the exact purpose is slightly under-specified.

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. Among the sibling tools, several handle URLs (e.g., 'normalize-url', 'browser-url-ok', 'domain-shape'), but the description does not mention when a Figma-specific parse is appropriate or when to prefer another tool. The context is implicit only through the tool name and the mention of Figma.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'No disk access,' which is a useful safety property, but it omits what the tool returns (e.g., a boolean), how it determines safety, or any error behavior. This is insufficient for an agent to predict the outcome of a call.

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, front-loaded with the purpose. It is concise and contains no filler. The only minor issue is that it omits necessary context, but the phrasing itself is efficient.

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

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

The tool has 9 parameters, yet the description focuses only on 'path' and does not explain the presence of the other eight parameters (ref, url, city, feed, host, json, zone, query). This is confusing because an agent might wonder why a 'file-path-ok' tool accepts a city or timezone. Additionally, there is no output schema, so the description should clarify the return format, which it does not. 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?

Schema description coverage is 100%, so each parameter is documented. The description adds no additional parameter meaning beyond what the schema already states for 'path'. Since the schema covers everything, the baseline is 3, and the description does not need to compensate.

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

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

The description states a clear verb ('Check') and resource ('whether a path looks safe'), which is distinct from sibling tools that check URLs, domains, or other shapes. It is not a tautology and gives a concrete purpose. However, it does not define what 'safe' means, 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?

There is no guidance on when to use this tool versus alternatives. It does not mention prerequisites, exclusions, or routing to other tools. An agent would have to infer that this is for file path validation from the name and description, but no explicit comparison to siblings like 'browser-url-ok' 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 must carry the full burden of behavioral disclosure. It only states that it returns coordinates via Open-Meteo, without mentioning network dependency, rate limits, or that most parameters are discarded. While it implies a read-only lookup, it does not explicitly disclose side effects or operational traits.

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

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

The description is a single, front-loaded sentence that states the core function immediately. It is appropriately concise with no wasted words. However, it is so minimal that it sacrifices necessary context, which is a structural trade-off; still, it earns a high score for conciseness.

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

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

Given the tool has 9 optional parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain which parameters are relevant for geocoding, what the return format is, or any error conditions. An agent would need to infer too much from the schema alone, making the definition inadequate for reliable 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 covers 100% of parameters with descriptions, so the baseline is 3. The description itself adds no parameter-specific guidance beyond the schema. Since the schema already explains each field (e.g., 'City name for a public weather hint; discarded after the call'), the description does not need to repeat that, but it also does not enhance understanding.

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

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

The description states a clear verb and resource: 'Latitude and longitude for a place via Open-Meteo.' It communicates the tool's core function succinctly. However, it does not distinguish it from siblings like 'weather-hint' or 'timezone', which may also relate to geographic data, leaving some ambiguity about when this specific tool is appropriate.

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 'weather-hint' or 'timezone'. The description does not mention which parameters to supply, nor does it exclude any usage scenarios. An agent would have to infer from the schema, but the description itself offers no usage context or selection criteria.

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

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

The word 'parse' implies a read-only operation with no side effects, but without annotations the description carries the full burden and does not mention behavior on invalid URLs, output format, or whether network access is involved.

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 concise sentence with no unnecessary words or filler.

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

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

The description is too sparse for the given schema: all 9 parameters are optional, yet the description does not say which parameter to supply, what the output structure is, or how invalid/non-GitHub inputs are handled.

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% parameter descriptions, many parameters (city, feed, json, path, zone, query) are irrelevant to parsing a GitHub URL. The description does not clarify that the 'url' parameter is the intended GitHub URL or that other fields are ignored.

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

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

The description clearly states a specific action and resource: 'Parse owner and repo from a GitHub URL.' This distinguishes it from sibling shape tools like domain-shape, figma-url-shape, and jira-key-shape.

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

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

The description gives no guidance on when to use this tool versus related URL/shape tools, nor does it specify constraints like 'only for GitHub URLs' or 'use normalize-url for non-GitHub URLs.'

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 only says it counts stories and that titles are discarded; it does not explain why nine unrelated parameters are present, whether the tool makes network calls, how the count is computed, or what the output format is. This is a major transparency gap for a tool that accepts many parameters.

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

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

The description is short (two sentences) and front-loaded with the main action, but the second sentence 'Titles discarded.' is vague and does not earn its place given the confusion it introduces. It is concise but not fully 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?

Given the tool has nine parameters, no annotations, and no output schema, the description is severely incomplete. It does not explain the role of the parameters, whether any are required for the count (though none are marked required), what the return value looks like, or any side effects. An agent has no way to correctly invoke this tool beyond 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 description adds no explanation for any parameter. The schema descriptions reference discarding or shape checks, but they are unrelated to the counting purpose, and the description does not clarify how parameters like 'ref', 'url', or 'path' relate to counting HN stories. While schema coverage is 100%, the descriptions are misleading and the description fails to compensate.

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 counts current Hacker News front-page stories, which is a specific verb+resource. It does not distinguish from siblings, but none of the listed siblings appear to overlap with HN counting, so the purpose is unambiguous.

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

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

No guidance is given on when to use this tool versus alternatives, nor any mention of prerequisites or exclusions. The description is entirely silent on usage context, leaving the agent to infer applicability.

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 disclosing behavior, but it does not mention read-only nature, side effects, ignored parameters, or what happens with the inputs. Several schema descriptions say values are discarded, but the main description gives no 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 very short and free of fluff, but it is too under-specified to be genuinely useful. It is concise in word count but not in conveying necessary information.

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

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

The tool has a complex, nine-parameter schema and no output schema, yet the description does not explain what the tool returns, how parameters are used, or when it should be selected. It is incomplete for reliable agent use.

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

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

Although the schema has 100% coverage, the parameter descriptions are largely unrelated to the stated IANA timezone purpose and include fields like ref, url, and json with no indication of which parameter is relevant. The descriptions add some meaning (e.g., discarded inputs) but do not clarify 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 'Common IANA timezone names for clock calls' identifies a domain but lacks a verb or explicit action, so it is unclear whether the tool returns a list, validates a name, or performs a lookup. It does not clearly distinguish the tool's function from related timezone 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?

There is no guidance about when to use this tool instead of alternatives such as timezone or utc-time, nor any conditions indicating when it is appropriate. The description provides no usage context at all.

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

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

No annotations are provided, and the description does not disclose side effects, permissions, error behavior, rate limits, or other behavioral aspects.

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

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

The description is extremely concise, using a single sentence with no unnecessary words, and is 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?

The tool has 9 parameters and no output schema, but the description fails to explain parameter usage or expected output. The mismatched parameter descriptions further reduce completeness.

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

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

The parameter descriptions in the schema are unrelated to robots.txt (e.g., Git ref, city, query), and the tool description does not clarify how parameters are used, making them misleading rather than meaningful.

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

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

The description clearly states the tool fetches a public robots.txt and returns group counts, but it does not distinguish this tool from siblings like web-fetch or fetch-status by naming an alternative.

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 instead of alternatives, nor does it mention prerequisites or typical scenarios.

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 disclosure is 'Key discarded', implying the input is not persisted. However, with no annotations provided, the description should explain what the tool returns (e.g., boolean, error message) and whether it makes any network calls or has side effects. This is insufficient for an agent to trust the tool.

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

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

The description is a single sentence, so it is concise, but it lacks essential structure such as a clear statement of the expected input format or output. It is under-specified rather than efficiently front-loaded; the one sentence does not earn its place by conveying critical 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 optional parameters, no output schema, no annotations, and a one-line description, the tool is critically incomplete. An agent cannot determine what to pass, what to expect back, or when to invoke it. The description fails to compensate for the absence of structured metadata.

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

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

Although the schema documents all 9 parameters (100% coverage), the description does not connect any of them to the Jira key concept. Parameters like 'city' and 'feed' appear unrelated to Jira keys, and there is no hint which parameter holds the key to check. The description adds no semantic value beyond the schema, and the mismatch between tool name and parameters creates 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 names a specific resource ('Jira issue key shape') and a verb ('Check'), but it doesn't define what a valid Jira key looks like (e.g., PROJECT-123) or how it differs from sibling shape tools like 'github-repo-shape' or 'domain-shape'. The term 'shape' is vague, and the tool's name is not enough to convey the exact format expected.

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

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

There is zero guidance on when to use this tool versus alternatives. No context about Jira key validation, no mention of when not to use it, and no reference to sibling tools. An agent would have no idea which scenario calls for this tool.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states that the body is discarded, which is a minor detail. It does not indicate whether the operation is read-only, whether it has side effects, requires authentication, or has rate limits. The schema descriptions mention 'discarded after the check' for several parameters, but the main description does not summarize this broader no-side-effect behavior.

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

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

The description is extremely terse, which is a form of under-specification rather than effective conciseness. It omits critical information about the tool's actual scope and behavior, so the single sentence does not earn its place by conveying necessary 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?

Given the tool has 9 parameters, no annotations, and no output schema, the description is severely incomplete. It does not explain how the parameters relate to the stated purpose, what the tool returns beyond a status code, or when to use it. An agent would have to inspect all parameter descriptions to infer the tool's actual behavior, which is excessive.

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

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

Schema description coverage is 100%, so each parameter is individually documented. The main description adds no parameter-level meaning, but it also does not contradict the schema. The baseline of 3 applies because the schema already provides sufficient semantic detail for each parameter, even though the description's narrow 'library docs' framing does not align with the 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 states a specific action (getting HTTP status for a public library docs URL) and mentions the body is discarded. However, it does not differentiate this from siblings like fetch-status or browser-url-ok, and the broad set of 9 parameters (city, zone, json, etc.) suggests the tool has a much wider scope than 'library docs URL' implies, making the stated purpose potentially misleading.

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

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

No guidance is given on when to use this tool versus the many siblings such as fetch-status, normalize-url, or browser-url-ok. The description does not mention prerequisites, exclusions, or the conditions under which this tool is preferred, 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. It does disclose that values are discarded, which is a useful behavioral trait, but it omits critical details such as what the output looks like, error behavior, or side effects. The mismatch between the description and the schema (no clear JSON-object parameter) further undermines 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 very short (two sentences) and front-loaded with the purpose, but it is under-specified rather than appropriately concise. It omits essential information about input and output, making it more of a teaser than a functional specification.

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 completely inadequate. It does not explain how the parameters relate to the operation, what counts as a 'JSON object', or what the return value is. The complexity of the schema demands a much richer description to be usable.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds no value about parameters. It does not clarify which parameter is the JSON object; the 'json' parameter's schema description says 'JSON text to validate', which is inconsistent with the tool's counting purpose. The description fails to connect its purpose to any specific parameter, leaving the agent confused.

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 ('Count') and resource ('keys in a JSON object'), which is a distinct purpose. However, it fails to specify which of the 9 input parameters carries the JSON object, and the schema's 'json' parameter is described as 'validate' rather than 'count', creating ambiguity about how the tool is actually invoked.

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 'validate-json' or 'domain-shape'. The description does not mention context, prerequisites, or exclusions, leaving the agent to guess when this is the appropriate choice.

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 mentions that query and fragment are dropped. It does not disclose that many schema parameters are ignored or that only 'url' is actually used, nor does it explain the return format, error behavior, or any side effects. The presence of numerous unrelated parameters in the schema without explanation creates 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 sentence that front-loads the core behavior and is free of fluff. It earns its place entirely, though the extreme brevity is a trade-off against 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 severely incomplete. It does not explain the role of the many non-URL parameters, whether they are ignored, or what the output looks like. An agent cannot reliably call this tool based on the description alone.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds no parameter-level meaning beyond the schema. Worse, the schema contains several parameters explicitly labeled as 'discarded' (ref, city, feed, json, query) which conflict with the tool's stated purpose of normalizing a URL. The description fails to clarify which parameter is relevant, leaving an agent uncertain about how to invoke the tool correctly.

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

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

The description clearly states the tool's function: 'Return origin, host, and path for a URL. Query and fragment are dropped.' It identifies the verb, resource, and scope. However, it does not distinguish this tool from its many siblings (e.g., figma-url-shape, github-repo-shape) that also operate on URLs, so it misses the differentiation that would merit 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?

No guidance is provided on when to use this tool versus alternatives. The description does not mention any context, prerequisites, or exclusions. An agent would have no basis to choose normalize-url over other URL-related siblings.

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

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

With no annotations, the description must fully disclose behavior. It reveals that no browser is launched, but fails to state whether a network request occurs, whether the operation is read-only, or what side effects might exist. The mechanism of the check and any return behavior are also unexplained.

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

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

The description is two sentences with no redundancy. The core action and the key differentiator (no browser) are front-loaded, making it efficient. It is appropriately sized for the tool's apparent simplicity, though it could benefit from a bit more 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?

For a tool with 9 optional parameters, no output schema, and many similar siblings, the description is incomplete. It doesn't explain what 'can be opened' means, what the tool returns, or how to decide between this and related tools like browser-url-ok or fetch-status. An agent would lack sufficient context 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 coverage is 100%, so every parameter already has a description. The tool description adds no parameter-level information, so it provides no extra semantics beyond what the schema already defines. Baseline 3 is appropriate for high schema 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 clearly states the action: 'Check whether a URL can be opened.' It also explicitly differentiates from siblings by noting 'No browser is launched,' which distinguishes it from browser-url-ok. The verb-resource pairing is specific and unambiguous.

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

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

The description implies a lightweight check without a browser but does not explicitly state when to use this tool versus alternatives like browser-url-ok or fetch-status. No exclusions or conditions are provided, leaving the agent to infer usage context from the 'no browser' hint.

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

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

No annotations are present, and the description adds one transparency detail: 'Query discarded.' It does not mention auth, rate limits, or any other side effects, but for a read-only character count the discard note is meaningful.

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 at two short sentences. It front-loads the action and states the key data-handling fact without padding.

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

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

For a simple character-count tool, the missing output schema is not a major issue, but the description leaves important context unclear: whether all characters count equally (whitespace, Unicode, etc.) and why the input schema includes many apparently irrelevant optional fields.

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 carries most parameter meaning. The description adds little beyond the schema's existing 'Search text; discarded after the length check' note, and it does not clarify why several unrelated optional parameters exist.

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: 'Count characters in a search query.' It does not explicitly distinguish itself from sibling tools, but the resource is specific enough that an agent can infer basic intent.

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. There are no conditions, prerequisites, or examples, leaving the agent to infer suitability from the name and one-line description.

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

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

There are no annotations. The description implies a read-only catalog but does not explicitly state side effects, parameter handling, output behavior, or rate limits. Schema descriptions hint that inputs are discarded, but the tool description itself is silent.

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

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

The description is a single sentence with minimal fluff and is easy to read. However, it is only a noun phrase and lacks any structured usage 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?

For a tool with 9 parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain what the tool returns, how parameters are used, or when to choose it.

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

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

All 9 parameters have descriptions, but none relate to HTTP status codes; they describe unrelated placeholders (git ref, URL, city, etc.) and phrases like 'discarded after shape check' add confusion rather than actionable meaning.

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

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

The description names the resource ('HTTP status codes') but lacks an explicit verb; 'catalog' is a noun phrase, so the action is only inferable. It distinguishes the tool from siblings only vaguely.

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 fetch-status or web-fetch. The description gives no selection criteria or context.

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

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

With no annotations, the description carries the full burden. It discloses the key behavioral trait: 'Prompt discarded' indicates input is ignored. This is transparent about the tool's behavior, though it does not elaborate on other aspects like side effects or return format.

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

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

Two sentences with zero waste, front-loaded with the purpose ('Return a three-step thinking template') before the behavioral note. Exceptionally concise and 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?

No output schema exists, so the description should explain the return value. It states 'three-step thinking template' but does not specify its content or format, leaving the agent without a clear picture of what to expect. While the tool is simple, the description is minimal and lacks detail about the template's structure.

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% and each parameter description already states it is discarded. The tool description adds a global 'Prompt discarded' statement, but this does not add new meaning beyond what the schema provides. Baseline 3 is appropriate.

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

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

States a clear verb (Return) and resource (three-step thinking template). It uniquely identifies the tool's purpose, distinguishing it from siblings through its specific name and action, though it does not explicitly reference alternatives.

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

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

No guidance on when to use this tool versus alternatives. It does not mention any context, exclusions, or conditions for invocation, leaving the agent to infer usage solely from the tool name.

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

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

No annotations are present, and the description gives no information about side effects, read-only behavior, error handling, or what happens with invalid timezone names. This leaves 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 focused sentence with no unnecessary words. It directly communicates the core functionality 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?

With no output schema and no annotations, the description is far too minimal. It fails to specify the output format, timezone validity behavior, or any error conditions, leaving critical context missing for an agent to use the tool effectively.

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

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

The schema has 100% parameter description coverage, so the baseline is 3. The description adds little beyond the schema, though it does align 'named IANA timezone' with the 'zone' parameter; however, it does not clarify that the other eight parameters are irrelevant or ignored.

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: returning the current time for a named IANA timezone. It is specific about the resource (timezone) and distinguishes itself from related tools like UTC time or weather hints.

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

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

No usage guidance is provided. The description does not mention when to use this tool over alternatives or any preconditions, making it unclear how to select it among the many sibling tools.

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

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

No annotations are provided, and the description does not disclose that the nine optional parameters are ignored or why they exist. Some parameter descriptions mention 'discarded' or 'no disk access', but the main description does not clarify the tool's actual behavior with respect to 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 extremely short and front-loaded, but it omits critical context about the parameter list. It is concise but at the expense of necessary clarification.

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 unrelated optional parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain the purpose of the parameters, whether they are ignored, or what the output format will be.

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, those descriptions are unrelated to a UTC timestamp (e.g., 'City name for a public weather hint', 'File path to check; no disk access'). They do not explain how these parameters affect the result, leaving the schema confusing and semantically disconnected from 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 'Current UTC timestamp' clearly states the tool's core purpose and distinguishes it from timezone-related siblings like `timezone` and `iana-zones`. However, it does not explicitly mention that the tool's many optional parameters are irrelevant to obtaining the timestamp.

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 `timezone` or `iana-zones`. The description only states what it returns, not when it should be preferred.

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

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

No annotations are provided, so the description must disclose behavior. It only says 'text discarded,' which is a vague statement about input handling and does not reveal return values, side effects, or error conditions. The tool's behavior is essentially 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 extremely short (one line) and under-specified. While it is concise in length, it omits essential information and does not earn its place; it is more a placeholder than a meaningful 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?

For a tool with 9 parameters, no output schema, and no annotations, the description is grossly incomplete. It does not state what the tool returns, how to invoke it correctly, or which parameter is relevant, making it impossible for an agent to use it effectively.

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 for each parameter are detailed (e.g., 'Git ref name; discarded after the shape check'), but the tool description does not connect these to the counting purpose. With 100% schema coverage the baseline is 3, but the description fails to clarify which parameter holds the text to be counted, so it adds no value beyond the schema and actually obscures the relationship.

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 'UTF-16 unit count, text discarded' names a specific operation (counting UTF-16 units) but does not specify which of the 9 parameters is the input text. It is not a tautology, but it fails to establish the resource or parameter being acted upon, leaving the tool's exact 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. It does not mention any conditions, exclusions, or alternative tools, leaving the agent without any basis for selection.

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

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

With no annotations, the description must carry the behavioral burden. It discloses that the body is discarded, implying a read-only, non-destructive operation, but it does not describe the return value (e.g., boolean, error message), side effects, or how the many unrelated parameters (city, feed, zone, etc.) are handled. The mention of discarding is a small positive, but major behavioral aspects are missing.

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, succinct sentence with no filler. It is appropriately front-loaded and every word contributes to the core message. While it is brief, it is not padded, so it earns a high score for conciseness.

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

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

The tool has nine parameters, no output schema, and no annotations, yet the description provides almost no context. It fails to explain which parameter to supply, what the result looks like, or how to interpret the outcome. This is severely incomplete for a tool of this complexity, leaving the agent to guess at usage.

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

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

Schema description coverage is 100%, and each parameter already has a description (e.g., 'json' states 'JSON text to validate; discarded after the check'). The tool description adds no additional semantic meaning beyond the schema; it does not clarify which parameter is the primary input or how the others relate. Baseline 3 is appropriate given the high schema 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 clearly states the core action: check whether a body is valid JSON. It distinguishes the tool from siblings that validate other shapes (e.g., domain-shape, file-path-ok). However, it does not specify which of the nine parameters constitutes 'the body', leaving the actual usage 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. There is no mention of prerequisites, exclusions, or conditions that would select this tool over sibling validators. The description is purely a statement of function without contextual routing.

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

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

With no annotations, the description carries the full burden of disclosing behavior, but it only states the output ('current temperature') and data source ('Open-Meteo'). It does not mention side effects, failure modes, rate limits, network dependence, or whether the operation is read-only. The schema mismatch also obscures what the tool actually does with its parameters.

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

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

The description is a single concise sentence with no unnecessary wording. It front-loads the primary purpose and data source. However, it is so terse that it omits important contextual information, though that is more a completeness issue than a conciseness issue.

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

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

Given the tool has nine optional parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain which parameters are relevant, how they map to the city temperature lookup, what the response format is, or what happens when parameters are omitted. The unrelated parameter descriptions add confusion rather than completing the context.

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

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

Although every parameter has a schema description, those descriptions are generic and largely inconsistent with the stated purpose. Parameters like ref, url, feed, host, json, path, zone, and query appear unrelated to returning a city temperature, and their descriptions use template phrases like 'discarded after the shape check' or 'no disk access'. The city parameter description even says 'discarded after the call', which contradicts 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 indicates the tool returns the current temperature for a city using the Open-Meteo service. It is specific enough to distinguish a weather lookup from general fetching or time-related tools. However, it is phrased as a noun phrase rather than an explicit verb like 'get' or 'retrieve'.

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

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

No usage guidance is provided about when to prefer this tool over siblings such as geo-hint, timezone, or web-fetch. The description does not mention required inputs, typical invocation scenarios, or when not to use it. This leaves the agent without actionable direction beyond the bare purpose.

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

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

The description discloses that the body is not returned, which is a useful behavioral detail. With no annotations provided, it does not fully cover side effects such as network access, redirects, timeout behavior, or rate limiting, but the core behavior of fetching a URL is implied by the tool name.

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, front-loads the primary purpose, and contains no filler or redundant wording. It is appropriately concise for the stated 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?

Despite the simple stated purpose, the nine-parameter schema is highly confusing and the description does not reconcile it with the tool's function. There is no explanation of output format beyond status/content type, how parameters relate to each other, or which parameter is the main input, leaving an agent without enough context to invoke the tool reliably.

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 tool description only relates to a URL, but the schema contains nine optional parameters covering git refs, cities, feeds, hosts, JSON, file paths, timezones, and search queries. The parameter descriptions are largely unrelated to 'web-fetch' (e.g., 'url' is described as 'HTTPS URL to normalize or cite', not to fetch), so the description fails to explain which parameters are actually used or how they interact.

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 HTTP status and content type for a public URL and that the body is discarded. It is specific about the resource type ('public URL') and the output scope, though it lacks an explicit verb and does not distinguish itself from sibling tools by name.

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

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

'Body discarded' implies the tool is for cases where only status/content type are needed, and 'public URL' hints at a public-only scope. However, it does not explicitly state when to prefer this tool over sibling tools such as fetch-status or browser-url-ok, nor when not to use it.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only mentions that the title is discarded, which hints at statelessness, but it does not disclose output format, error behavior, or any side effects. This is insufficient for a tool with no annotation coverage.

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

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

The description is two short sentences with no fluff, achieving conciseness. The purpose is front-loaded, and the note about discarding the title is brief. However, it is too sparse to be fully helpful, but conciseness itself is not penalized heavily.

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

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

Given 9 parameters, none required, no output schema, and no annotations, this description is grossly incomplete. It does not specify which parameter is the title, what the return value looks like (boolean, status, etc.), or any error conditions. An agent cannot reliably call 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% (all 9 parameters have descriptions), so the baseline is 3. The description does not add meaning beyond the schema—it fails to identify which parameter represents the Wikipedia title (likely 'query' but not stated). It neither clarifies parameter relationships nor compensates for the schema's generic 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 states a clear action: 'Check whether a Wikipedia title exists.' This is a specific verb and resource, but it does not distinguish from sibling tools or clarify which parameter holds the title. The name reinforces the purpose, yet the schema's many unrelated parameters introduce 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 is given on when to use this tool versus alternatives like 'browser-url-ok' or 'fetch-status'. There is no mention of exclusions, prerequisites, or context in which this tool is preferred. The description leaves usage entirely to inference.

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