ISO country SZ

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotenceHint=true, and the description adds a meaningful behavioral trait: 'Task text discarded.' It also discloses that the tool returns remote MCP hops, which is useful context not present in annotations. No contradiction exists.

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

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

The description is three short sentences, with no filler. The first sentence states purpose, the second lists return contents, and the third gives a data-handling caveat. Each sentence earns its place and the structure is 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?

There is no output schema, so the description appropriately lists return contents. It does not explain what 'Monid' is or detail invocation prerequisites, but the schema covers all parameters and annotations cover safety. It is adequate for a read-only discovery 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?

All seven parameters have schema descriptions, so schema coverage is 100% and the baseline applies. The description adds no parameter-specific detail, but the schema already fully documents each 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 uses a specific verb ('Find') and names the exact resource ('public pay-per-call tool gateway (Monid)'), then lists concrete outputs ('CLI setup, how-it-works, skill file, and remote MCP hops'). This makes the tool's function clear and distinguishes it from sibling fetch/URL tools even though the tool name itself is generic.

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 establishes a clear context for use—finding the Monid pay-per-call gateway—but it does not explicitly state when not to use it or name alternatives. Usage is implied rather than directly contrasted with sibling tools like web-fetch or fetch-status.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does usefully disclose that no browser is launched, which is a meaningful behavioral trait. However, it does not mention whether a network request occurs, what kind of result is returned, error behavior, or any side effects.

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

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

The description is exactly two sentences with no wasted words. The core action is front-loaded and the important behavioral caveat about not launching a browser follows immediately.

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

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

For a tool with 9 optional parameters, no annotations, no output schema, and several closely related siblings, this one-liner is not sufficient. It does not tell the agent which input to provide, what the result means, or how this tool relates to alternatives like web-fetch, normalize-url, or playwright-url-ok.

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

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

Schema description coverage is 100%, so the baseline is 3 and the description does not need to restate parameter meanings. Still, with 9 optional parameters, the description does not clarify which parameter is the URL to check, leaving some ambiguity for an agent selecting inputs.

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

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

The description clearly states a specific check action on URLs and explicitly notes that no browser is launched, which adds useful distinction. However, it does not explain what 'can be opened' means operationally, and it does not name or differentiate sibling tools, so it falls short of a 5.

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

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

The statement 'No browser is launched' implies this tool is the lightweight, non-browser option compared to tools like playwright-url-ok or web-fetch. But there is no explicit guidance on when to use it, when not to use it, or which alternative to prefer, so usage context is only implied.

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

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

With no annotations provided, the description must disclose side effects and state changes itself. It only says 'Expression discarded,' which hints that the input is not persisted but is too ambiguous and fails to state whether a result is returned, how errors are reported, or whether any external state is touched.

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 core action, which is good. But 'Expression discarded' is ambiguous and arguably redundant with the schema's discard language, so the second sentence does not earn its place clearly.

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, no output schema, and the nine optional schema parameters are unrelated to arithmetic, so the one-line description cannot make the tool safely callable. Missing are the expression parameter mapping, result/return expectations, and the meaning of 'discarded.'

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

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

The schema lists nine parameters with descriptions but none can carry an arithmetic expression. The description mentions an 'Expression' that has no corresponding property, and additionalProperties is false, so an agent cannot construct a valid call that matches 'a+b style arithmetic.' This is a direct parameter-semantics failure.

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?

'Evaluate a+b style arithmetic' is a specific verb-plus-resource statement; among the many validators and URL/domain tools, it uniquely identifies this tool as the arithmetic evaluator. No other sibling covers calculation, so it is distinguishable without further context.

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 action phrase implies the primary use case: evaluate simple arithmetic expressions. However, the description gives no explicit when-to-use/when-not-to-use guidance, no mention of alternatives, and no constraints such as supported operators or input limits.

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

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

With no annotations, the description must disclose behavior, but it only states the record is public. It does not describe what happens to the supplied parameters, whether any network or disk access occurs, or what the response contains; the per-parameter 'discarded' notes live in the schema, not the tool description.

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

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

The single sentence is terse, but it is under-specified rather than efficiently structured. For a tool with 9 parameters and no other documentation, one noun phrase does not earn its place as an adequate description.

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

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

The tool is complex enough (9 optional params, no output schema, no annotations) that the description is far from complete. It omits return value shape, side effects, and selection criteria, making correct invocation largely guesswork.

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. However, the tool description adds no semantic link between those parameters and the stated ISO 3166-1 record, leaving the agent to infer why url, json, path, and query 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 names a resource ('Public ISO 3166-1 record for SZ') but states no verb or operation, so it is unclear whether the tool returns, validates, or looks up data. The 9 optional parameters (url, json, path, zone, etc.) are not tied to this ISO record, creating ambiguity, and nothing distinguishes it from siblings like geo-hint 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?

There is no guidance about when to call this tool or when to prefer an alternative. It does not mention prerequisites, exclusions, or any relationship to sibling tools such as geo-hint, timezone, or validate-json, despite the schema suggesting unrelated inputs.

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?

Because no annotations are provided, the description carries the full disclosure burden. It does add an important behavioral fact ('Page content is not stored') and implies a network request via HTTP status, but it leaves side effects, redirect behavior, and the role of the many discarded parameters 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?

Two short sentences with the main result front-loaded and a meaningful privacy/behavior note in the second sentence. 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?

For a URL-metadata request, calling with only 'url' is supported and the returned values are named, so the description is minimally usable. However, with nine optional parameters, no output schema, and no annotations, it leaves the overall scope ambiguous—especially why city, feed, JSON, path, timezone, and query parameters exist.

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

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

Schema description coverage is 100%, so the baseline is 3 and each parameter has an individual explanation. The description adds only the output context for the URL parameter and does not clarify the meaning or selection logic for the other eight optional parameters, but it does not contradict 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 result (host, scheme, HTTP status) for a specific resource (a URL), so the core operation is clear. It does not explicitly distinguish itself from sibling URL tools like fetch-status or normalize-url, but the 'Page content is not stored' clause provides some differentiation.

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

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

There is no guidance about when to prefer this tool over the many sibling URL/status tools, nor any when-not-to-use or alternative conditions. The only implicit cue is that it operates on a URL and does not store page content, which is not enough for routing decisions.

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 meaningful privacy behavior: 'No identifiers are retained.' With no annotations provided, this partially compensates for the lack of side-effect disclosure, but it still does not mention whether there are network calls, output behavior, or other retention implications beyond identifiers.

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 action is front-loaded. It is concise and readable, though the brevity contributes to ambiguity elsewhere.

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

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

With nine optional parameters, no output schema, and no annotations, the description leaves out critical context: what the returned classification looks like, whether one or multiple parameters should be supplied, and what 'this request' refers to. The schema descriptions help but do not resolve the overall invocation contract.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself adds no parameter-level detail, but it does not need to because every parameter already has a clear schema description explaining its purpose and disposal.

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 ('show how this request is classified'), so it is not a pure tautology. However, it is vague about what 'classified' means, what classification categories look like, and how this tool differs from sibling shape-checking 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 on when to use this tool versus any of its many siblings. No conditions, alternatives, or exclusions are provided, so an agent cannot determine when compatibility is the right 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 must carry behavioral weight; it does disclose that the tool will not perform WHOIS/ownership lookup and implies a pure local split. However, it does not mention how irrelevant parameters are handled, whether a valid hostname is required, or any error/edge-case 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 with no filler; verb and object appear first and the WHOIS exclusion is a useful qualifier. This is appropriately concise.

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

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

Despite a well-covered schema, the description alone leaves the agent unsure of the primary parameter, output format, and error behavior, especially since the schema contains many seemingly unrelated optional params. No output schema or annotations exist, so the terse description is insufficient for confident 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%, with property descriptions like 'Public hostname' and 'discarded after the shape check' already documenting each parameter. The tool description adds no extra param semantics beyond identifying hostname as the input concept, so the baseline 3 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 concrete operation ('split a hostname into labels') and states a clear non-goal ('without WHOIS or ownership data'), so the core purpose is understandable. It does not explicitly contrast with sibling tools, but the hostname scope separates it from URL/path/JSON 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 statement of when to prefer this tool over siblings, no example trigger, and no mention of alternatives. The negative scope is the only hint, which is insufficient guidance for an agent deciding among many shape/URL 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 must disclose behavior, and it does reveal the HEAD method and public-URL constraint. However, it never explains how the other eight schema parameters (ref, city, json, path, zone, query, etc.) affect behavior or what a returned 'status' looks like; the schema's own parameter descriptions ('normalize or cite', 'discarded after the shape check') point to behavior not covered by the description.

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

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

The one-sentence description is front-loaded and free of filler, with the verb in the first word. It is appropriately terse for a simple status-check tool, though the brevity hides the complexity of the nine-parameter 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?

No output schema and no annotations mean the description must specify return format and scope; 'status only' does not say whether the result is an HTTP code, a string, or an object. It also does not address the nine optional parameters, zero-required behavior, or sibling alternatives, so the definition 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?

Schema coverage is 100%, so the baseline is 3, but the description adds no useful parameter guidance and even seems inconsistent with the schema: the `url` parameter is described as 'HTTPS URL to normalize or cite,' not as a URL to HEAD, and it is unclear whether `feed` or `host` are alternatives or irrelevant. An agent cannot reliably choose which parameter to populate.

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

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

The description names a specific action (HEAD) and a precise result ('status only'), so an agent can see this is a lightweight URL status check. It does not, however, distinguish this tool from sibling URL tools like web-fetch, browser-url-ok, or playwright-url-ok.

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

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

'Return status only' implies the tool is for lightweight checks where the response body is not needed, but there is no explicit when-to-use guidance, no alternatives named, and no exclusions such as 'use web-fetch for full content.' This is implied usage at best.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It does reveal one trait—'Path discarded'—but does not explain whether the tool validates, normalizes, extracts, or returns a value, nor does it describe side effects or failure behavior. This is insufficient for a tool with no annotation support.

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. Every word earns some place. The second sentence, 'Path discarded,' is cryptic, which slightly reduces structural clarity, but the overall conciseness is strong.

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 should clarify what the caller receives after parsing. It does not mention the return format, validation outcome, or whether 'path discarded' refers to the URL path or an input parameter. The tool may work, but an agent lacks enough context to confidently interpret its 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?

Schema description coverage is 100%, so the schema already documents all parameters. The description adds little parameter-level meaning beyond clarifying that the target input is a Figma file URL. It does not specify which parameter carries the URL or how the 'path discarded' note relates to the schema's actual path 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 verb and resource: 'Parse a Figma file URL.' This clearly identifies what the tool operates on and distinguishes it from sibling shape-checkers like github-repo-shape or jira-key-shape. The phrase 'Path discarded' adds a behavioral detail but is ambiguous enough to prevent 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?

The description implies when to use the tool: when a Figma file URL needs parsing. However, it does not explicitly state when not to use it or name alternative tools for other URL or shape checks. Usage is conveyed but not fully developed.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It does explicitly disclose 'No disk access,' which is a meaningful safety-relevant trait for a path-validation tool. However, it does not disclose whether it makes network calls, what it returns, how it handles invalid input, or what 'safe' means in terms of path syntax.

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

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

The description is a single, front-loaded sentence with no wasted words. 'Check whether a path looks safe' states the core purpose immediately, and 'No disk access' adds essential behavioral context without padding. It is an exemplary concise 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?

Despite the schema being fairly rich, the description is incomplete in critical ways: it does not define what counts as a safe path, does not indicate the return type or success/failure behavior, and does not explain how the many non-path parameters relate to the tool. With no output schema and no annotations, an agent would not have enough information to correctly invoke this tool in ambiguous cases.

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 already provides descriptions for all seven parameters, so the baseline for description-added value is 3. The description names 'path' as the focus, but it does not clarify why the schema also accepts ref, url, city, feed, host, and json, nor whether these are alternative inputs, ignored values, or unrelated fields. Overall, the description adds little beyond the schema's own parameter documentation.

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

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

The description uses a clear verb and resource ('Check whether a path looks safe'), and the tool name reinforces the intended operation. It is distinguishable from sibling shape-checkers because it targets paths rather than URLs, domains, or wiki titles. However, 'looks safe' is left vague and does not define what 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 is given about when to use this tool versus sibling shape-checkers such as normalize-url, domain-shape, or wiki-title-ok. The only contextual hint is 'No disk access,' which implies a non-filesystem-shape check, but it does not state when this tool should be preferred or what input types it is not appropriate for.

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 reveals the external data source and the returned coordinate type; it does not state whether the operation is read-only, whether inputs are discarded or persisted, what error behavior to expect, or the response 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?

The description is a single short sentence with no filler, and the core output is front-loaded. It is efficient, though the brevity comes at the cost of omitted usage and invocation details.

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

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

With nine optional parameters, no required fields, no output schema, and no annotations, a one-sentence description is not enough. It omits the return shape, the parameter to use, and any relationship to sibling tools, so an agent cannot reliably select or call the tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3 even without parameter info in the description. However, the description does not map any parameter to the geocoding purpose; the only plausible candidate, city, is described as 'for a public weather hint,' and all nine parameters are optional, leaving the agent unsure which one to populate.

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

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

The description states the output — latitude and longitude via Open-Meteo — but it never specifies what counts as 'a place' or which input parameter supplies it. It is not a tautology, but it is only vaguely actionable and does not distinguish from sibling tools like weather-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?

There is no guidance on when to use this tool versus alternatives. The description does not mention weather-hint, timezone, or any other sibling, nor does it give conditions like 'use when you need coordinates for a city before fetching weather.'

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 states the parse action and does not disclose whether the operation is read-only, whether it performs validation, how invalid URLs are handled, or what happens with the multiple accepted-but-discarded parameters. The schema descriptions mention discarding, but the description itself adds no 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 a single sentence that is front-loaded with the verb and target. It contains no filler, no repetition, and no unnecessary detail. Every word contributes to stating the tool's purpose.

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

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

With nine optional parameters, no output schema, and no annotations, a one-sentence description leaves important calling questions unanswered: which parameter to pass, what the return value looks like, and how invalid or unexpected inputs behave. The description does not tie the broad schema together into complete guidance for an agent.

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

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

Schema description coverage is 100%, so the baseline is 3 even without parameter information in the description. The description adds the idea that a GitHub URL is the relevant input, but it does not name the 'url' parameter or explain how the other eight optional parameters relate. The schema carries the parameter-detail load.

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 opens with a specific verb ('Parse'), names the resource ('owner and repo'), and scopes the input to a 'GitHub URL'. This is enough to distinguish it from sibling shape tools such as figma-url-shape or jira-key-shape. The core function is unambiguous.

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

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

The description implies the tool should be used when the agent has a GitHub URL and needs the owner and repo, but it never explicitly states when to prefer it over sibling URL-shape tools or when not to use it. There is no alternative routing or exclusion, so guidance remains implicit rather than 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?

With no annotations, the description must carry the behavioral burden. 'Titles discarded' is a meaningful behavioral disclosure about output shape, and 'current' implies live data. But it does not mention side effects, network behavior, failure modes, or output format beyond the count.

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 highly concise and front-loaded: 'Count current Hacker News front-page stories. Titles discarded.' Each sentence earns its place. The only structural issue is that 'Titles discarded' is terse enough to be ambiguous about whether input titles are ignored or output titles are omitted.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, the description is too sparse. It does not state which parameters are relevant, what the returned count represents, how failures are reported, or whether the tool should be called with zero arguments.

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

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

Although the schema descriptions cover 100% of parameters, the tool description does not explain how any of the nine optional parameters relate to 'counting Hacker News front-page stories.' The only slight connection is 'Titles discarded' echoing the feed parameter, but the agent is left without guidance on which parameter, if any, 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 states a specific verb and resource: 'Count current Hacker News front-page stories.' This clearly distinguishes it from sibling tools like web-fetch or normalize-url. 'Titles discarded' further sharpens the purpose by clarifying that the tool returns a count, not a listing.

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 when to use the tool: whenever the current Hacker News front-page story count is needed. However, the description gives no explicit context about when not to use it or which sibling tools would be alternatives, and the strange optional parameters make invocation ambiguous.

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 must carry the full behavioral burden. It does not state whether the tool returns a list, accepts a lookup, performs a validation, or what happens with the many 'discarded' inputs; it only names the subject matter.

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 free of clutter, but it is under-specified rather than efficiently structured. It conveys a topic, not a callable behavior, so conciseness comes at the expense of usefulness.

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

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

With 9 optional parameters, no output schema, no annotations, and many sibling tools, this description is too incomplete for an agent to invoke the tool correctly. Missing are the operation, return shape, parameter priorities, and relationship to other time/clock tools.

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

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

Schema coverage is 100%, with each parameter already described, so the baseline is 3. The description does not add meaning beyond the schema, but it does faintly align with the 'zone' parameter; the other eight parameters remain unexplained at the tool level.

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

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

The description identifies the resource (IANA timezone names) and a broad context (clock calls), but it lacks a verb such as 'returns' or 'lists' and does not distinguish itself from sibling tools like timezone or utc-time. An agent gets a rough idea of subject matter but not a precise operation.

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 timezone, utc-time, or other siblings. The phrase 'for clock calls' implies a context but does not clarify prerequisites, alternatives, or conditions for invocation.

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

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

With no annotations, the description carries the burden of disclosing behavior. It does say the fetch targets public robots.txt and that only group counts are returned, indicating a read-only, aggregate operation. However, it does not mention error behavior, timeouts, redirects, or that many supplied parameters are discarded after validation.

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; 'group counts only' adds meaningful output scope. It earns its place, but it is slightly too terse given the complexity of the input schema.

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

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

A 9-parameter schema with no required fields, no annotations, and no output schema demands far more context than this. The agent cannot determine which parameter to use, what the returned group counts look like, or how failures are surfaced. The description is not sufficient 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?

Although schema coverage is 100%, the parameter descriptions are generic and not tied to robots.txt. The description never explains whether the agent should supply 'url' or 'host' to select the target, and several parameters ('city', 'feed', 'json', etc.) are clearly irrelevant yet still present. This makes correct 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 description names a specific verb and resource ('Fetch a public robots.txt') and states the exact result ('return group counts only'). This clearly distinguishes it from broader fetch/status tools like web-fetch and fetch-status, which would return more content or status information.

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 siblings such as web-fetch, fetch-status, or normalize-url. The only usage signal is the implicit connection between the tool name and robots.txt, so the agent must infer when this tool is the right 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 provided, the description carries the transparency burden. 'Key discarded' discloses a meaningful behavioral trait: the input is not retained after the check. Still, it does not describe the return value, whether any external call is made, or what 'discarded' operationally means, so the disclosure is better than nothing but incomplete.

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

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

The description is extremely short and front-loaded, with no wasted words. The second sentence about discarding the key adds useful behavioral information. However, the brevity comes at the cost of essential parameter and output details, so it is concise but under-specified.

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

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

Given nine parameters, no required parameters, no annotations, and no output schema, the description is not sufficiently complete. It does not explain which parameter carries the Jira key, what the check result looks like, or what 'shape' means. An agent would struggle to invoke this tool correctly without additional context.

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

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

The input schema contains nine parameters, all with descriptions, but they appear unrelated to Jira key validation—url, city, feed, json, zone, query, etc. The description refers to a 'key' but no parameter named 'key' exists; the closest candidate, 'ref', is described as a Git ref name. This mismatch leaves an agent unable to confidently determine which parameter to pass.

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

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

The description clearly identifies the action ('Check') and the resource ('a Jira issue key shape'), and the tool name distinguishes it from sibling shape-checking tools like domain-shape and github-repo-shape. However, it does not specify what a valid shape is or which input parameter holds the key, 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?

The intended use is implied by the tool name and phrasing: use it when you need to verify whether a string matches a Jira issue key shape. There is no explicit guidance about when not to use it or which sibling tool might be a better alternative, so the usage context is only implicit.

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 behavioral disclosure burden. It usefully states that the body is discarded and only an HTTP status is returned, but it does not mention request method, redirect handling, error behavior, rate limits, or auth expectations.

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 behavior and the key body-discarding detail are front-loaded and easy to parse.

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

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

Given 9 parameters, no annotations, and no output schema, the description is too thin. It does not explain which parameter drives the library-docs check, what the returned status looks like, or why many schema fields appear unrelated to the stated purpose.

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 9 parameters, most with explicit 'discarded' notes, so the schema carries most of the parameter-level meaning. The tool description adds the HTTP-status intent but does not clarify how the 'docs URL' purpose relates to unrelated parameters such as city, zone, or query.

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 reports an HTTP status for a public library docs URL and discards the body, so an agent knows the core behavior. It does not explicitly differentiate this from sibling URL/status tools like fetch-status or browser-url-ok, and the broad 9-parameter schema makes the intended scope less crisp.

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

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

The phrase 'for a public library docs URL' implies when to use it, but there are no explicit conditions, exclusions, or references to alternative tools. An agent has to infer which sibling tool is preferred for generic URL checks versus library-docs checks.

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

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

With no annotations, the description carries the behavioral burden. It does disclose one important trait: values are discarded and only keys are counted. But it does not mention whether the input is validated, what happens with invalid JSON, 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 and front-loads the core behavior with no filler. It is concise, though the brevity sacrifices important 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?

For a tool with 9 optional parameters, no required fields, and no output schema, this description is incomplete. It does not state the return value, which parameter supplies the JSON object, or what happens with invalid JSON or non-object JSON.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds no explicit parameter mapping, though 'JSON object' loosely points to the `json` field. However, the schema's `json` description frames it as validation rather than key-counting, so the description does little to clarify which of the 9 optional parameters is actually required for the intended 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 the action (count keys) and the resource (a JSON object), which differentiates it from siblings like validate-json. However, it never ties the action to the `json` parameter, and the 'memory' part of the tool name is unexplained.

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

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

The description gives no guidance on when to use this tool versus alternatives such as validate-json or search-query-len. There are no exclusions, prerequisites, or examples of appropriate use cases.

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

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

With no annotations, the description carries the behavioral burden. It does disclose one meaningful behavior: 'Query and fragment are dropped.' It does not explain behavior for invalid URLs, whether other schema fields are ignored, or the exact return structure.

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

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

Two sentences with no filler. The main purpose is front-loaded, and the second sentence adds a concise behavioral detail. 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 has nine optional parameters, no output schema, and no annotations, but the description only addresses URL normalization. It does not clarify whether only `url` matters, what happens with the other fields, or what the returned data shape looks like, leaving substantial ambiguity for correct invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds little parameter-level meaning beyond the schema; it clarifies URL query/fragment behavior but does not help an agent map the nine unrelated optional properties to this tool's actual usage.

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: 'Return origin, host, and path for a URL.' This distinguishes it from fetching or checking tools, though it does not explicitly contrast it with siblings like browser-url-ok or playwright-url-ok.

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

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

The use case is implied: use this tool when you need a URL normalized to origin, host, and path with query/fragment removed. However, it gives no explicit guidance about when to prefer this tool over any of the many URL-related siblings, nor does it state any exclusions.

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

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

The description discloses the important behavioral trait that no browser is launched, which is useful. It does not say whether the check performs a network request, what response codes count as 'ok', or whether any state is changed; annotations are only flagged as present, so the description carries some burden.

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 main action, and contains no filler. Every clause 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 purpose is stated, but for a tool with seven parameters and no output schema the description does not explain what a positive or negative result looks like or what 'can be opened' means operationally. The parameter descriptions fill part of the gap, but a caller must infer the return contract from the name.

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 seven parameters already have individual descriptions in the schema, so schema coverage is high and the baseline is 3. The tool description adds no parameter-level meaning beyond the schema's own 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 uses a clear verb ('Check') and a specific resource ('whether a URL can be opened'), and the added 'No browser is launched' narrows the meaning and implicitly separates it from browser-url-ok. It does not name sibling tools explicitly, so it stops short of full differentiation.

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

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

There is no explicit guidance on when to use this tool instead of browser-url-ok, fetch-status, or normalize-url. The 'No browser is launched' sentence hints at a lightweight use case but leaves the selection criteria 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?

The description explicitly discloses that the query is discarded, which is a meaningful privacy/behavioral trait given that no annotations are present. It does not describe return behavior or counting rules (e.g., whitespace or encoding), so the burden is only partially met.

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 terse sentences with no filler: the first names the operation and the second states the disposal guarantee. It is front-loaded and skimmable, appropriate for a simple utility.

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 has no output schema and no annotations, but the description's 'Count characters' implies the return value and the well-documented parameters mitigate invocation ambiguity. The definition is minimally adequate for a trivial tool, though it leaves the exact output format and the fact that only `query` is relevant unstated.

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 explains every parameter, including `query` ('Search text; discarded after the length check'). The tool description adds no parameter-level meaning, matching the baseline of 3 for high-coverage schemas.

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 operation ('Count characters') on a specific resource ('search query'), so an agent knows what action is performed. It does not, however, name the relevant `query` parameter or distinguish itself from sibling count/length tools, so it is clear but not fully differentiated.

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

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

The description provides no guidance on when to use this tool versus alternatives such as `memory-key-count`, `normalize-url`, or `validate-json`. There are no exclusion conditions or context cues beyond the tool name, so an agent must 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only labels the tool as a 'catalog' and does not state whether it is read-only, whether it makes network calls, what it returns, or how the accepted parameters affect behavior. Some schema descriptions mention values being 'discarded', but the tool description itself does not disclose these 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 short and front-loaded, but the brevity comes from omitting action, usage, and output information. It reads as under-specification rather than efficient conciseness, since the phrase mostly restates the tool name and does not earn its place with operational detail.

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

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

With 9 optional parameters, no required parameters, no annotations, and no output schema, a single noun phrase is inadequate. The description does not explain what the tool returns, whether any parameters are needed, why parameters like city, zone, or json appear in a status-code catalog, or how to retrieve the catalog itself.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds no parameter meaning, and the schema descriptions themselves describe parameters in terms of unrelated checks ('discarded after the shape check', 'discarded after the length check') that never connect to HTTP status codes, leaving a semantic gap.

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 that essentially restates the tool name: 'Short catalog of common HTTP status codes' adds 'HTTP/common' but still lacks a verb such as 'returns', 'lists', or 'looks up'. It also does not reconcile with the input schema, which contains unrelated optional parameters like ref, city, json, and zone, so an agent cannot tell what action the tool performs.

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 siblings like fetch-status, no indication of whether to call it with no arguments or with one of the nine optional parameters, and no exclusions or alternatives. The only implied use is 'when you need HTTP status code information', but that is not stated as actionable 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?

With no annotations, the description carries the transparency burden. 'Prompt discarded' does disclose that the user prompt is ignored, which is a meaningful trait, but it mostly repeats the per-parameter 'discarded' notes in the schema and does not describe the template output or 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?

Two short sentences front-load the action ('Return...') and then give the key caveat. There is no filler, redundancy, or unnecessary detail.

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

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

For a trivial fixed-template tool, the description is mostly adequate, but with no output schema it only vaguely identifies the return value as a 'three-step thinking template' and never explicitly states that all arguments are irrelevant. An agent can invoke it, but not with full confidence about the exact output.

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 main description adds no parameter-level meaning beyond what the schema already documents; all nine parameters are individually described as optional or discarded.

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 and output: 'Return a three-step thinking template.' This distinguishes it from sibling tools that fetch, validate, or inspect data. However, it does not explicitly contrast it with any sibling or clarify exactly why a caller would choose this tool.

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

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

No when-to-use guidance or alternatives are provided. 'Prompt discarded' is a behavioral caveat rather than a routing instruction, so an agent gets no help deciding between this and 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, so the description carries the full behavioral disclosure burden. It says the tool reports current time but does not disclose that other schema parameters appear irrelevant/ignored, that the timezone input is non-optional in practice, or what happens with an invalid timezone 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 a single concise sentence with no filler and the key idea is front-loaded. However, it is arguably too terse for the confusing nine-parameter schema it accompanies.

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

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

For a tool with no annotations, no output schema, and a noisy nine-parameter input schema, this description is incomplete. It does not state that timezone is the only relevant input, that the other fields are ignored, or what the response will look like.

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

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

Although schema coverage is 100%, the schema contains eight mostly unrelated parameters (ref, url, city, feed, host, json, path, what) that seem copied from other tools. The description does not clarify that only 'timezone' is meaningful, leaving an agent uncertain about which parameter to populate for this 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 states the core operation clearly: get the current time for a named IANA timezone. This distinguishes it from siblings like utc-time and iana-zones, though it does not explicitly name them or explain the difference.

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 you need current time in a specific IANA timezone. However, it provides no explicit guidance about when not to use it or which sibling tool to choose instead, such as utc-time for UTC.

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 burden of disclosing behavior, but it only states a result and does not mention side effects, return format, precision, or how the numerous input parameters are handled. The schema suggests parameters like ref and json are 'discarded,' but the tool description itself 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 extremely concise and front-loaded, stating the core purpose in four words. It lacks structure and additional helpful context, but for such a simple operation, brevity is appropriate.

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

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

The tool has no annotations and no output schema, while the input schema contains nine optional parameters that are not explained in the description. An agent cannot tell whether to pass parameters, what output format to expect, or why parameters like url and city appear in the schema, making the definition incomplete for confident invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter meaning, but the schema already describes each parameter individually; however, the parameters themselves appear unrelated to a UTC timestamp, and the description does not clarify which ones matter.

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

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

The description clearly states the tool returns the current UTC timestamp, which is a specific, unambiguous purpose. It is distinguishable from sibling tools like timezone and iana-zones by emphasizing 'UTC' and 'current,' though it does not explicitly name any sibling.

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

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

There is no guidance about when to use this tool versus alternatives like timezone or other utility tools. The description provides no context about prerequisites, exclusions, or why an agent should choose 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?

The description does disclose a meaningful side effect: 'The body is discarded.' Without annotations, the description carries the burden, but it does not state whether the tool returns a boolean, an error, or nothing, nor what happens for invalid JSON.

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: two short sentences with no filler. The primary purpose is front-loaded, followed by the key side effect.

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 validator, the core operation is stated, but the description does not clarify which parameter represents the 'body' or how the result is conveyed. The mismatched schema properties create enough ambiguity that more context would help, especially given there is no output schema.

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

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

The input schema gives each parameter a description, so schema coverage is 100%. The description itself adds no parameter-level meaning, and 'body' is not mapped to a named parameter. The presence of seemingly unrelated properties like `city`, `feed`, and `host` adds confusion without additional explanation.

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

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

The description states a clear action and object: 'Check whether a body is valid JSON.' This distinguishes it from the sibling URL/domain/shape-checking tools, which focus on non-JSON formats. However, 'body' is not explicitly mapped to the `json` input parameter, so a slight ambiguity remains.

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?

Usage is implied by the name and description: use this tool when you need to validate JSON. No alternatives or when-not-to-use conditions are stated, and no guidance is given about the other schema fields such as `url`, `city`, or `feed`.

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 an external dependency on Open-Meteo but says nothing about expected inputs, error conditions, side effects, or what happens with the unrelated schema parameters. The schema descriptions hint that values are discarded, but the description itself does not.

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

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

The description is a single concise sentence with no filler. It front-loads the core function and the data source, though it omits a verb and any usage 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 no output schema and no annotations, this description is under-specified. An agent cannot determine the required parameter among nine optional ones, what response format to expect, or what makes this different from other hint tools. The mismatch between the weather description and the generic schema further reduces completeness.

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

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

Schema description coverage is 100%, so the baseline applies. The description adds no parameter details beyond mentioning city, which is already described in the schema. It doesn't clarify why the other eight parameters exist or how they relate to the weather function.

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's purpose as returning current temperature for a city via Open-Meteo. This is a specific, identifiable function that distinguishes it from siblings like geo-hint, though it is phrased as a noun phrase rather than an explicit verb.

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 prefer this tool over alternatives such as geo-hint, web-fetch, or fetch-status. The schema lists nine optional parameters, but the description does not indicate which should be provided for a weather lookup.

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 disclosure burden. It usefully reveals that the response body is discarded and that the tool targets public URLs, implying no auth/private access. It does not mention redirects, timeouts, or rate limits, but it covers the most important unexpected 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?

Two short sentences with no filler. The main behavior is front-loaded and the body-discard caveat follows immediately.

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

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

The tool has nine optional parameters, no output schema, and no annotations, so more context is needed than a one-liner. The description does not resolve the ambiguous schema, explain what the response looks like, or state what happens when non-URL parameters are supplied.

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

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

Although schema coverage is 100%, the schema is contradictory and noisy: the url property is described as 'normalize or cite', and seven unrelated optional parameters (city, feed, host, json, path, zone, query) are present. The description does not specify which parameter is the URL to fetch or whether the extraneous parameters 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 names a concrete operation (return HTTP status and content type) on a specific resource (public URL), and explicitly says the body is discarded. It does not explicitly differentiate from siblings like fetch-status or browser-url-ok, so it falls just short of a 5.

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

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

There is no guidance on when to choose this tool over sibling tools such as fetch-status, browser-url-ok, normalize-url, or playwright-url-ok. No alternatives, exclusions, or conditions are mentioned, leaving the agent to infer usage from the one-line 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?

There are no annotations, so the description carries the behavioral burden. It does disclose that the title is discarded after the call, which signals a stateless read operation, but it does not describe output, network behavior, errors, or any other side effects.

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

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

The description is two short sentences and front-loads the core operation. The second sentence adds a useful data-handling note with little waste, though it could be integrated more cleanly.

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 large heterogeneous schema and lack of annotations and output schema, the description is not sufficient to invoke the tool correctly. It omits which parameter is the title, what response shape indicates existence, and why the other 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?

The schema descriptions cover all parameters, so the baseline would be 3, but the description refers to a 'title' that does not appear anywhere in the input schema. It does not map the required title to a property and actually misleads an agent into looking for a title parameter among seven unrelated fields.

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

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

The description states a concrete operation: checking whether a Wikipedia title exists, with a specific resource and verb. It is not a tautology and distinguishes this from nearby validation tools, though it does not name any sibling 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?

No guidance is given for when to use this tool instead of siblings such as fetch-status, validate-json, or normalize-url. The description offers no selection conditions, prerequisites, or exclusions, so an agent must infer usage from the name alone.

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