Currency SEK

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

With no annotations present, the description carries the full burden and does disclose one important behavioral trait: task text is discarded after the call. It also says the tool returns specific artifacts and frames the operation as finding rather than mutating. However, it does not disclose whether this involves external network calls, authentication, costs, rate limits, or failure behavior, so significant behavioral detail is 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 extremely concise: one sentence for purpose and returns, plus a short warning fragment. It front-loads the primary action and output list before the behavioral caveat. Every clause earns its place and there is no repetition of schema 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?

With no output schema and seven apparently unrelated optional inputs, the description leaves critical questions open: which parameters are relevant, whether any are required, and how the inputs map to the returned CLI setup or skill file. It lists output categories but not their structure or selection logic. An agent cannot confidently decide what to pass or how to interpret 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?

The input schema already documents all seven parameters with descriptions, and schema description coverage is 100%, so the baseline is 3. The tool description adds no parameter-level meaning and does not explain how ref, url, city, feed, host, or json relate to the returned artifacts. The description neither improves nor harms the parameter understanding provided by the schema.

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

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

The description states a concrete purpose: find a public pay-per-call tool gateway called Monid and returns specific artifacts (CLI setup, how-it-works, skill file, remote MCP hops). It names a verb, a resource, and the expected output, which separates it from generic fetch or validation tools. Monid itself is unexplained, but the core action is still clear.

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

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

There is no explicit when-to-use, when-not-to-use, or alternative-tool guidance relative to the many siblings. The only hint is 'Task text discarded', which warns against passing task text, but it does not name alternatives or state the conditions that favor this tool over web-fetch, validate-json, or similar. The agent is left to infer the appropriate usage context.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure. It only reveals that no browser is launched, but does not say whether a network request is made, whether it returns a boolean or status, whether the check is purely shape-based, or what happens on failure. The schema hints that inputs are 'discarded after the shape check,' but the description omits this important behavioral context.

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

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

The description is only two sentences and leads with the core action. The second sentence, 'No browser is launched,' is a useful differentiation. It is economical, though so terse that it omits essential context.

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

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

There is no output schema and no annotations, so the description must explain the check's result and behavior, but it does not. Given the unusually broad and mismatched input schema, the description is too incomplete for an agent to invoke the tool correctly, especially regarding required parameters, return values, and how this relates to 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?

Although the schema has descriptions for every property, those descriptions point to unrelated behaviors like 'normalize or cite,' 'weather hint,' and 'JSON text to validate.' The tool description provides no guidance about which parameter is relevant for the stated URL check, nor does it clarify why eight heterogeneous parameters exist. Without a required list or selection guidance, the agent cannot confidently map the description onto the schema.

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

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

The description states a specific verb and resource ('Check whether a URL can be opened') and adds a distinguishing behavioral note ('No browser is launched'), which separates it from sibling tools like playwright-url-ok. However, the broad input schema with unrelated properties like city, json, and path muddies what the tool actually operates on, so the purpose is not crisply matched to the schema.

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

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

The description gives a hint that the URL check does not launch a browser, implying a lightweight alternative to browser-based checks, but it never says when to use this tool versus siblings such as playwright-url-ok or web-fetch. There is no explicit context, prerequisite, or exclusion guidance, so the agent must infer usage from the tool name and one sentence.

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 already provide readOnlyHint=true, destructiveHint=false, and idempotenceHint=true, covering the safety profile. The description adds the behavioral trait that the expression is discarded, which is useful context beyond the annotations. No contradiction is present.

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, with two short sentences and no wasted words. It front-loads the core action. However, the terseness leaves out important output details, slightly reducing the 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?

There is no output schema and the description does not state what the tool returns (e.g., a boolean shape-check result or a numeric evaluation). With a large parameter list and no guidance on which parameters are relevant, the description is incomplete 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?

All parameters already have schema descriptions, giving 100% coverage, so the baseline is 3. The description adds minimal extra meaning—'a+b style' hints at the expected expression syntax—but does not clarify the roles of the many other unrelated parameters.

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

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

The description states a specific action ('Evaluate a+b style arithmetic') and resource (arithmetic expressions), which distinguishes it from sibling shape-check tools like domain-shape or validate-json. However, 'Expression discarded' is ambiguous about whether the result is returned, preventing a perfect score.

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

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

No guidance is given about when to use this tool versus alternatives. It does not mention any sibling tools or describe the context in which arithmetic evaluation should be chosen over other shape-check or validation 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. It adds one useful privacy trait ('Page content is not stored'), but it does not explain required inputs, failure behavior, whether requests are made, or any side effects. This is too thin for an unannotated network-related tool.

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

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

Two short sentences, front-loaded with the result and followed by a valuable privacy note. No filler words or redundant restatements of 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?

The tool has seven parameters, no annotations, and no output schema, yet the description only names the URL and the three return fields. It fails to explain which parameter is required, how errors are surfaced, or why the other parameters exist, leaving significant gaps for correct invocation.

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

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

The input schema already describes all seven parameters, so the baseline is 3. The description adds that the URL is the central input and that host/scheme/status are outputs, which helps slightly, but it does not disambiguate the many discarded or decoy-looking parameters such as host, path, and json.

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 result (host, scheme, HTTP status) for a URL, which makes the core purpose clear. It does not explicitly distinguish itself from sibling tools like fetch-status or normalize-url, so it falls short of full sibling differentiation.

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

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

The description gives no guidance on when to use this tool versus siblings such as fetch-status, normalize-url, or web-fetch. There are no exclusions, conditions, or alternative recommendations, leaving the agent to infer usage from the purpose alone.

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

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

The description adds a useful privacy note, 'No identifiers are retained,' and the schema repeats that many inputs are discarded. With no annotations to carry the behavioral burden, this is helpful but still omits any detail about side effects, permissions, or output 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 text is short and front-loaded, and the privacy sentence has clear value. However, the first sentence is so vague that the brevity undermines rather than aids clarity.

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 vague purpose, the description is incomplete. It does not explain what classification result will be returned, what criteria are used, or how this tool relates to the many similar-looking siblings.

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 itself does not explain any parameters, but the input schema already provides per-parameter descriptions for all seven fields. Since schema coverage is complete, a baseline 3 is appropriate.

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

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

The description says only 'Show how this request is classified,' but never defines what 'this request' is or what 'classified' means in this tool's context. It does not distinguish the tool from sibling validation utilities like validate-json or normalize-url, and it borders on tautology.

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

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

There is no guidance about when to use this tool versus any of its many siblings. No contexts, exclusions, or alternative tool names 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 provided, the description carries the full behavioral disclosure burden. It does disclose an important limitation ('without WHOIS or ownership data'), which adds useful context. But it does not describe failure behavior, normalization rules, or the fact that many schema parameters are described as discarded after the 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 a single sentence with no filler, and the core behavior is stated upfront. Every word contributes meaning: the operation, the input type, and the key limitation.

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 seven optional parameters, no annotations, no output schema, and no required field information, one sentence is insufficient. The description leaves an agent unsure which parameter to populate and what the return shape or error behavior looks like.

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

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

Schema descriptions cover all seven parameters, so the baseline is 3 even without parameter detail in the tool description. The description adds no disambiguation between the `host` property and the numerous other properties like `url`, `path`, or `json`, which is a notable gap given the unusual schema. Still, it does not actively mislead, so the baseline applies.

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 operation with a clear verb and resource: 'Split a hostname into labels.' The qualifier 'without WHOIS or ownership data' also distinguishes it from domain information lookups. It does not explicitly contrast with sibling tools, but the verb+resource alone makes the tool's role fairly 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 that the tool should be used when hostname label splitting is needed and explicitly warns that it will not provide WHOIS or ownership data. However, it does not name alternative tools or conditions for when to prefer this over siblings like normalize-url or other shape-checking tools.

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

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

There are no annotations, so the description carries the full burden. It only discloses the HTTP method and output scope; it does not explain redirect handling, timeouts, error behavior, or what happens to the many other accepted parameters. The broad input schema makes this gap more serious.

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 admirably short and front-loaded, with every word earning its place. However, for a tool with seven parameters and no annotations, this level of brevity leaves important operational details unaddressed.

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

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

With no annotations, no output schema, and a seven-parameter input schema, a single sentence is not enough. An agent cannot tell which parameters are relevant, what the status return value looks like, or how this tool differs from similar sibling tools beyond the basic method.

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 describes all seven parameters, so the baseline is 3, but the description adds no mapping between them and the HEAD operation. The schema's own 'url' description ('to normalize or cite') conflicts with the described HEAD purpose, and the description does not clarify which parameters are actually used 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 a specific verb (HEAD), a resource (public URL), and the output (status only). It is immediately distinguishable from content-fetching or URL-normalizing siblings like web-fetch and normalize-url.

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

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

The phrase 'return status only' gives a clear context for when this tool is appropriate: lightweight status checks without fetching page content. It does not explicitly name alternatives or exclusion conditions, but the intended use is reasonably clear.

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

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

No annotations are provided, so the description must carry behavioral disclosure. It offers only 'Path discarded,' which is ambiguous and largely repeats what the schema already says for the path parameter. Nothing is said about side effects, return values, or failure behavior, leaving the agent without a clear behavioral model.

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 the main action is front-loaded. 'Path discarded' is terse, but there is no wasted wording.

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, the description needs to identify the meaningful input, expected result, and which fields are irrelevant. It only mentions Figma URL parsing and an ambiguous discard, leaving an agent to infer how to invoke the tool correctly.

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

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

Schema coverage for parameters is 100%, so the baseline is 3. The description adds minimal context beyond the schema, mainly suggesting the URL parameter is the Figma URL and that path is ignored. It does not clarify which of the other eight parameters 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 states a specific verb and resource: 'Parse a Figma file URL.' The Figma mention distinguishes it from sibling shape tools like github-repo-shape or jira-key-shape. However, 'Path discarded' is ambiguous, so the purpose is slightly undercut.

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 explicit when-to-use or when-not-to-use guidance, and no sibling tools are referenced. The intended use for Figma file URLs is only implied by the name and 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?

No annotations are present, so the description carries the disclosure burden. 'No disk access' explicitly states a key behavioral boundary, and 'looks safe' implies a pure syntactic/shape check. However, it does not say whether the tool ever reads any input, returns a boolean, or has any edge-case caveats.

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. It front-loads the function and immediately states the important non-side-effect behavior. 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?

The tool is more complex than the description implies: its schema accepts seven largely unrelated inputs (ref, url, city, feed, host, json, path), yet the description only talks about paths. It does not explain which parameter to use, what happens with the others, or why this differs from the related sibling tools. This leaves agents without enough context 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?

The input schema provides rich descriptions for all parameters, including notes about discarded values, so schema coverage is high. The description itself adds no extra parameter meaning and only mentions 'path', leaving the relationship between the other six parameters and the path-focused purpose unexplained.

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

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

The description states a clear, specific purpose: 'Check whether a path looks safe.' This distinguishes it from URL-focused siblings like browser-url-ok and normalize-url by using 'path', but 'looks safe' is vague and does not define what safety criteria are checked.

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 about when to prefer this tool over alternatives. It does not reference the sibling tools or explain why file-path-ok should be chosen instead of normalize-url, browser-url-ok, or validate-json when the input schema also accepts URL and JSON 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only mentions the data provider and output concept, but does not describe the network call, that the input is discarded, possible side effects, or response format. The schema hints at discard behavior, but the 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 no fluff, and the core subject ('latitude and longitude') is front-loaded. It is concise, though bordering on under-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?

With seven parameters, no annotations, and no output schema, a one-sentence description is inadequate. The agent is not told which parameter to supply, what the response looks like, or how failures are reported.

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. The description adds no parameter-specific meaning. The schema descriptions are generic and some say 'discarded after the call,' which may confuse whether 'city' is the intended input for coordinates.

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

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

The description states the tool provides latitude and longitude for a place via Open-Meteo, which identifies a specific resource and external service. It is distinguishable from sibling tools like weather-hint because it focuses on geographic coordinates rather than forecasts, though it lacks an explicit verb like 'gets' or 'returns'.

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 such as weather-hint, timezone, or iana-zones. There is no mention of the appropriate input parameter, any prerequisites, or exclusion 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 carries the behavioral transparency burden. 'Parse' conveys a read-only, non-mutating operation, but it does not disclose behavior for invalid URLs, return format, or the fact that many input fields are discarded.

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

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

A single clear sentence with no filler. The core behavior is front-loaded and every word adds value.

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 exposes eight fields with no required markers, and there is no output schema or annotations. The one-line description does not tell an agent which inputs actually matter, what the tool returns, or how it handles irrelevant fields, making it incomplete 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?

All eight schema parameters already have descriptions, so the baseline is 3. The description adds mild specificity by identifying url as a GitHub URL, but it adds no meaning for the other parameters and may create confusion about why fields like city, feed, and json are present.

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 a concrete resource ('owner and repo from a GitHub URL'). This immediately makes the tool's job clear and differentiates it from sibling shape tools like domain-shape or jira-key-shape.

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

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

The purpose implies the tool should be used when a GitHub URL is present and owner/repo extraction is needed. However, it gives no explicit when-to-use conditions, exclusions, or alternatives among the many related URL and shape tools.

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

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

With no annotations, the description carries the full burden of explaining side effects, network access, and output behavior. It only says 'Titles discarded,' but does not disclose that the tool likely fetches live data, whether it is read-only, or that the many optional parameters appear to be ignored for the count itself.

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

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

The description is very short and front-loaded, with no filler. It efficiently states the main purpose and a key output limitation. However, it is arguably too terse given the confusing nine-parameter schema, which could have used at least a sentence of 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?

The description leaves important gaps: it does not specify what the returned count looks like, why so many unrelated parameters exist, whether any parameters should be passed, or how failures are handled. With no output schema and no annotations, these gaps make the tool harder to invoke confidently.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description itself adds no parameter-level meaning. The schema descriptions are unusual and hint that many values are discarded after checks, but the description does not help connect any of the nine parameters to the actual counting behavior.

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

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

The description clearly states a specific action and resource: count current Hacker News front-page stories. The added phrase 'Titles discarded' clarifies that the result is a count rather than a list of titles, which distinguishes it from fetch-style sibling tools.

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

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

The description implies when to use the tool: when a count of current HN front-page stories is needed. 'Titles discarded' provides a useful exclusion: do not use this tool if story titles are needed. However, no alternative tools are named and no explicit when-not-to-use guidance 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 exist, so the description carries the full burden of behavioral disclosure. It only states what the names are for, not what the tool does when called, what it returns, or how the input parameters relate to the 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?

A single, front-loaded sentence communicates the core purpose without wasted words. It is concise, though it achieves brevity at the expense of necessary behavioral and usage detail.

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

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

With seven parameters, no annotations, and no output schema, the description is too sparse to let an agent confidently call the tool. It does not explain what input matters, how the discarded parameters are used, or what a response would contain.

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 gives detailed descriptions for all parameters, many noting they are discarded after checks, so schema coverage is high and the description need not repeat them. However, the description creates no connection between the timezone-name purpose and the seven unrelated parameters, leaving invocation semantics unclear.

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 ('Common IANA timezone names') and its intended use ('for clock calls'), which distinguishes it as a reference vocabulary. However, it lacks a verb and does not clarify whether the tool returns a list, validates a timezone, or provides a constant.

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 'for clock calls' implies context but does not say when to choose this tool over siblings like timezone or utc-time. No alternatives, exclusions, or conditions are provided.

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

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

The description adds 'public' (suggesting unauthenticated access) and 'group counts only' (output limitation), which are genuinely useful beyond the readOnlyHint and destructiveHint annotations. It does not cover failure modes or edge cases, but it adds meaningful behavioral scope.

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

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

One sentence, front-loaded with the action, and no wasted words. The key restriction ('group counts only') is included without elaboration.

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

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

The tool is simple, but the complete absence of parameter mapping makes it incomplete for safe invocation. The description also omits error behavior for robots.txt absence or invalid URLs, and with no output schema the agent is left guessing at the exact return shape.

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 describes all seven parameters generically, but the description never says which parameter should contain the robots.txt location. An agent cannot reliably choose between 'url', 'host', or 'path', so the description fails to bridge the tool-level purpose to the actual parameters.

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

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

The description states a specific verb and resource: fetch a public robots.txt and return only group counts. The 'only' qualifier sharply distinguishes this from sibling tools like web-fetch or fetch-status, making the tool's scope immediately 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?

The description implies the tool is for cases where robots.txt group counts are enough, rather than full content, but it never names alternatives or states when not to use it. Usage context is inferable, not explicit.

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 claim 'Key discarded' implies a side-effect-free check, but no 'key' parameter exists in the schema. With no annotations to fill the gap, the description actively obscures rather than discloses the tool's actual behavior and 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 text is brief and front-loaded, but it is too minimal to be useful. The second sentence ('Key discarded') does not earn its place because it refers to an input that is not present in the schema.

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

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

With nine optional parameters and no output schema, the description leaves critical context missing: which parameter carries the Jira key, what output is returned, and what validation rule defines an acceptable shape.

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 does not map any of the nine schema parameters to its purpose and introduces a phantom 'key' argument. The individual parameter descriptions mention discarding and no disk access, but they are unrelated to Jira keys, leaving invocation ambiguous.

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 phrase 'Check a Jira issue key shape' states a high-level intent, but it never identifies the input to use or defines what a valid 'shape' is. The schema contains no 'key' parameter, so the purpose is ambiguous despite the tool 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?

No guidance is given about when to choose this tool over sibling shape-checking tools such as domain-shape or github-repo-shape. There is also no mention of prerequisites, alternatives, or 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?

There are no annotations, so the description must carry the behavioral burden. It discloses that the body is discarded, which is useful, but it does not explain how the many other parameters are handled, whether the tool performs a lightweight check, or what it returns beyond an HTTP status. The discrepancy between the described 'library docs URL' focus and the broad parameter list adds confusion rather than transparency.

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

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

The description is extremely short (one sentence) and front-loaded with the core action, which is concise. However, it is under-specified to the point of being unhelpful; it omits essential context about the tool's scope, parameter usage, and relationship to siblings. The brevity is not balanced with the 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?

With 9 optional parameters, no annotations, and no output schema, this description is grossly incomplete. It fails to explain which parameter is the main input, what the tool does with the other parameters, what the output format is (beyond HTTP status), or how it differs from related tools. An agent cannot reliably invoke this tool correctly based on the given information.

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

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

Schema description coverage is 100%, so each parameter is already documented. The description adds no additional meaning about which parameter is primary or how they interact. It mentions 'URL' generically but does not clarify that the 'url' parameter is the target, nor does it explain the discarded parameters. Baseline 3 applies since the schema covers semantics and the description provides no extra value.

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

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

The description states a specific action ('HTTP status for a public library docs URL') but this does not align with the parameter schema, which includes unrelated fields like city, feed, host, json, path, zone, and query. It appears to describe a generic HTTP status checker while the name and description imply a library-docs-specific hint tool, making the purpose ambiguous and 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 provided on when to use this tool versus siblings such as fetch-status, browser-url-ok, or normalize-url. The description does not mention alternatives, prerequisites, or conditions that would route an agent to this tool over others.

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

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

With no annotations present, the description carries the behavioral burden and does add one useful trait: 'Values discarded.' However, it does not state whether the count is top-level only, what the return value is, or whether any 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 two short sentences with no filler. The main action is front-loaded and the discarded-values clarification 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 nine optional parameters and no output schema, this definition is incomplete. It never explains that the JSON object being counted is the invocation's own set of arguments, whether the count is recursive, or what the tool returns. An agent may misidentify the json parameter as the object source.

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 reinforces the schema's 'discarded' notes, but it does not clarify which parameter holds the JSON object or how multiple optional parameters should be supplied.

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

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

The description clearly identifies the operation: count keys in a JSON object, with values discarded. It is specific enough to distinguish this from validation or length-check tools, though it does not explicitly name 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?

There is no guidance on when to use this tool versus siblings like validate-json or search-query-len. No conditions, exclusions, or alternative routing are provided, so the agent must infer usage from the name and schema.

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 itself. It clearly discloses that query and fragment are dropped and that only origin, host, and path are returned. It does not mention that non-URL parameters appear irrelevant, but the schema descriptions already label them as discarded.

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

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

Two short, front-loaded sentences with no filler. The first states the primary purpose and the second adds the key exclusion (query/fragment dropped). 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?

The description explains the return values and the dropped components, which is adequate for the core operation. However, with seven parameters and no output schema, it leaves ambiguity about whether only `url` should be supplied and how the other parameters relate to the tool's behavior.

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

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

Schema descriptions cover 100% of the parameters, so the baseline is 3. The main description adds little parameter-level meaning beyond implying that `url` is the operative input; it does not clarify the role of the many discarded parameters.

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

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

The description states a specific verb ('Return') and a precise resource ('origin, host, and path for a URL'), making the tool's core function clear. It distinguishes the tool from fetch/validation siblings in spirit, though it does not explicitly name any 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 intended use is implied: an agent would reach for it when it needs URL components while dropping query and fragment. However, there is no explicit when-to-use guidance, exclusions, or mention of alternatives like browser-url-ok or web-fetch.

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

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

No annotations are provided, so the description carries the full transparency burden. It discloses one behavior ('No browser is launched') but does not say whether a network request is made, what side effects or prerequisites exist, or what 'ok' means in terms of return/status. Significant behavioral gaps remain.

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 wasted words. The core action and the key behavioral constraint are front-loaded. This is appropriately concise given the tool's apparent simplicity.

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

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

With 9 parameters, no annotations, and no output schema, the description is too thin to be complete. It does not explain return values, success/failure semantics, which parameter to pass, or why unrelated-looking params exist in the schema. An agent would need additional context to invoke it confidently.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no parameter-level detail and actually emphasizes only URL while the schema includes many optional params such as city, json, and path. Agents must rely entirely on 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?

States a clear verb and resource: 'Check whether a URL can be opened.' The 'No browser is launched' hint helps distinguish it from the sibling browser-url-ok, though it does not explicitly name that alternative. This is specific enough for an agent to understand the core 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?

No when-to-use or alternative routing is provided. The description says no browser is launched, which implies a lightweight check, but it never explains when to choose this tool over browser-url-ok, web-fetch, or fetch-status. Usage context is left to inference.

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

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

With no annotations, the description must carry the behavioral burden. It does disclose that the query is discarded, which suggests no persistence or side effects beyond counting. However, it does not explain how characters are counted, what the return value looks like, or any edge-case behavior, so transparency is only partial.

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

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

The description is two short, front-loaded sentences with no filler. Both sentences earn their place: one states the core function and the other discloses the discard 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 is conceptually simple, but the mismatch between the description and the input schema is a critical gap. Without annotations, an output schema, or a 'query' property, an agent cannot reliably know how to invoke this tool. The schema's wrapper note hints that more detail exists but does not provide it here.

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 documents seven string properties, but none is named 'query' and the tool description never maps 'search query' to any parameter. Schema coverage is high in a formal sense, but the property descriptions are unrelated to the stated purpose, so an agent cannot determine which value to pass. The description 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 clear action ('Count characters') and a clear resource ('a search query'), and it adds a side-effect note ('Query discarded'). It is specific enough to distinguish the basic operation, though it does not explicitly differentiate it from sibling counting tools or identify the actual input parameter.

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. It names no sibling tools, no exclusion conditions, and no context in which this tool is preferred over related tools like memory-key-count or hn-front-count.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It says only 'short catalog' and gives no indication of what happens to the seven input parameters (some are discarded, some are cited), what processing occurs, or what output is produced. The behavior is entirely 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 superficially concise ('Short catalog of common HTTP status codes') but is under-specified to the point of being unhelpful. This is not tight, meaningful conciseness but rather a lack of substance. The single sentence does not earn its place because it conveys almost no operational 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 seven parameters, no annotations, and no output schema, this one-sentence description is drastically incomplete. It does not explain which parameter(s) to provide, how the 'catalog' relates to the inputs, what the tool returns, or how it differs from sibling tools. An agent would have no way to correctly invoke this tool.

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

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

The input schema provides detailed descriptions for all seven parameters (e.g., 'Git ref name; discarded after the shape check'), giving high schema coverage. The tool description itself adds no parameter information, but since schema coverage is high, the baseline of 3 applies. The description does not compensate for any gaps, but also doesn't need to.

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 ('Short catalog of common HTTP status codes') with no verb indicating what the tool does when invoked. It names a resource (HTTP status codes) but fails to state the action (e.g., look up, validate, return) or how it relates to the many input parameters. This is more vague than a tautology but still leaves the tool's 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?

There is zero guidance on when to use this tool versus siblings like fetch-status, web-fetch, or the various *-shape tools. No conditions, exclusions, or alternative routing hints are provided. An agent cannot determine if this tool is for looking up status codes, validating inputs, or something else.

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

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

The description does disclose one meaningful behavior: 'Prompt discarded,' which signals that the prompt is not used. However, with no annotations and a fairly large input schema, it leaves unclear whether any parameters are actually consumed, whether the output is fixed, or what side effects exist.

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 core action is front-loaded. It is appropriately concise for a simple constant-return tool, though brevity comes at the cost of missing contextual 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?

There are no annotations and no output schema, while the input schema has eight parameters. The description does not explain whether any input is required, how to invoke the tool correctly, or what the three-step template actually contains. 'Prompt discarded' helps but is insufficient.

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

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

The input schema provides descriptions for every parameter, so coverage is high and the baseline is 3. The top-level description adds no parameter meaning and the phrase 'Prompt discarded' creates ambiguity about whether the listed parameters are truly used 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 states a specific action ('Return') and a concrete resource ('three-step thinking template'), so the core purpose is clear. It does not explain what the three steps are or explicitly distinguish this tool from siblings, but it is not vague or tautological.

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 any sibling tool, no alternatives listed, and no exclusions. The only usage clue is implied by the phrase 'three-step thinking template,' which is not enough.

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 conveys a read-style lookup, but says nothing about output format, what happens on invalid timezone names, dependencies, or side effects. For a tool with no annotations, this 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 a single front-loaded sentence with no filler or repetition. Every word contributes to stating the tool's purpose, even though other dimensions suffer from the extreme brevity.

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

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

Despite the tool's apparent simplicity, the description omits the crucial mapping between 'named IANA timezone' and the parameters, and no output schema or annotations fill that gap. An agent cannot confidently determine which parameter to pass or what result to expect.

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 says 'named IANA timezone,' but the input schema contains no timezone parameter at all; the closest candidate, 'city', is described as a weather hint that is discarded. The 7 schema parameters are individually documented, but they are unrelated to the described purpose, and the description does nothing to map the required timezone input onto any parameter.

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

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

The description states a specific operation: obtaining the current time for a named IANA timezone. This is clear and distinguishes it from siblings like iana-zones (zone list) and utc-time (UTC clock), though it doesn't explicitly name those 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?

The description implies the tool is for current time in a named IANA timezone, but gives no guidance on when to prefer it over utc-time or iana-zones, nor any exclusion or alternative. An agent must infer the intended usage from the tool 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Current UTC timestamp' and does not disclose that input parameters are effectively ignored, that no network or disk access occurs, or what output format is returned.

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 concept is front-loaded. Every word earns its place, though the brevity limits the information conveyed.

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, and nine optional parameters, yet the description is only five words. It fails to explain invocation expectations, the output format, or how it relates to sibling time-related tools, which is inadequate for reliable correct 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?

Schema description coverage is 100%, so the schema already documents every parameter. The description adds no parameter-level meaning and does not clarify whether any parameter influences the timestamp, but the baseline of 3 applies because the schema covers the semantics.

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

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

The description clearly says the tool provides the current UTC timestamp, identifying the resource and basic function. However, it lacks an explicit verb like 'get' or 'return' and does not distinguish itself from sibling tools such as timezone or iana-zones.

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

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

No guidance is given about when to use this tool versus alternatives, nor about whether any of the nine optional parameters should be supplied. Since the description is minimal and parameters are all optional, an agent gets no help deciding how to invoke it.

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

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

The description explicitly discloses that the body is discarded, which is meaningful side-effect transparency given no annotations are present. However, it does not state what the tool returns (boolean, error, status) or whether validation is purely syntactic, leaving the no-annotation safety and outcome profile only partially described.

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

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

The description is two short sentences with no filler and the core purpose is front-loaded. The second sentence about discarding is useful and earns its place, though the overall terseness borders on under-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?

With no output schema, the description must communicate what the caller receives, but it does not say whether the tool returns a boolean, an error, or some other result. It also does not clarify how the many optional schema parameters interact with 'body' or when to prefer this tool over sibling validators, leaving a meaningful 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 the baseline is 3. The description adds only a general 'body is discarded' lifecycle note and does not clarify which parameter carries the JSON text; the schema's `json` parameter already provides the needed semantic, so the description adds no real value beyond the schema.

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

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

The first sentence states a concrete action ('check') and object ('whether a body is valid JSON'), going beyond merely restating the tool name. It does not connect 'body' to the schema's `json` parameter or contrast with sibling validators, so it is not 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 validate-json instead of sibling tools, no mention of what counts as the input body, and no exclusions or prerequisites. The only implied context is the tool name and one-line purpose, which provides no real decision support.

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

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

There are no annotations, so the description carries the full burden. It only mentions the core function and backend, without disclosing that many shape-check parameters are ignored, whether the operation is read-only, or what the response format 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 a single, front-loaded sentence with no filler. Every word adds context, and it is immediately readable.

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 seven parameters, most unrelated to weather, no output schema, and no annotations, the description is too minimal. It does not clarify that the extra parameters are discarded or shape-checked, nor what the returned temperature data looks like.

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

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

The input schema already describes all seven parameters, so the description adds little beyond reinforcing that 'city' is the meaningful weather input. The schema coverage is high, so a baseline of 3 is appropriate.

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

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

The description states a specific function: returning current temperature for a city, and names the data source (Open-Meteo). It is clear on the core purpose, though it does not explicitly differentiate itself from sibling 'hint' tools like geo-hint or lib-docs-hint.

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

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

The description provides no guidance on when to use this tool versus alternatives, no exclusions, and no conditions. An agent has no basis to decide between weather-hint and related hint 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 provided, the description carries the disclosure burden. It does reveal an important behavioral trait—'Body discarded'—which prevents agents from expecting page content, and it restricts the target to public URLs. However, it does not mention redirect handling, timeouts, user-agent behavior, or error/status semantics, so disclosure is partial.

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

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

The description is exactly two short sentences with no filler; the primary function is front-loaded and the behavioral caveat earns a second sentence.

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

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

For a network tool with no annotations and no output schema, this is incomplete. It states the two output values but not their format, error behavior, or which schema parameter to supply, and the schema's seven loosely-related optional fields create confusion that the description does not resolve.

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

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

The schema provides descriptions for all seven parameters, so the baseline is 3. The tool description adds little parameter-specific meaning beyond implying the 'url' field, and it does not resolve which of the multiple URL-ish fields such as url, host, or feed is appropriate for web-fetch.

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

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

The description states that the tool returns HTTP status and content type for a public URL and explicitly notes the body is discarded, making the core purpose clear and distinguishing it from a status-only sibling like fetch-status. It lacks an explicit action verb such as 'fetches' or 'returns', so it stops short of a fully specified 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 choose web-fetch over comparable siblings such as fetch-status, browser-url-ok, playwright-url-ok, or normalize-url. The only usage hint is 'public URL,' which excludes private/internal resources but gives no explicit alternatives or when-not-to-use 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?

The description mentions 'Title discarded after the call,' but the schema contains no title parameter, making the behavioral note confusing rather than informative. No side effects, network behavior, or output semantics are disclosed.

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 with the main purpose. However, the second sentence ('Title discarded after the call') is confusing because no title input exists in the schema, so it does not earn 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?

The description is incomplete for the tool's complexity: it does not explain which parameter is the title, what the output represents (e.g., boolean existence flag), what error behavior occurs, or why the many unrelated parameters are present.

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, those descriptions are generic and mismatched (e.g., 'Git ref name,' 'IANA timezone name'), none of which clearly relate to checking a Wikipedia title. The tool description adds no meaningful parameter semantics and fails to identify which field should receive the title.

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

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

The description states a concrete action: 'Check whether a Wikipedia title exists.' This distinguishes it from many sibling tools, but no 'title' parameter appears in the input schema, so the purpose is not fully aligned with the tool's actual interface.

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 explicit guidance on when to use this tool versus alternatives like browser-url-ok, fetch-status, or web-fetch. The existence-checking purpose is implied but not contextualized, and no when-not-to-use information is provided.

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