Currency HKD

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

With no annotations provided, the description carries the behavioral burden. It does disclose a meaningful behavioral trait: 'Task text discarded.' It also implies a read-only lookup by saying 'Find' and lists what it 'Returns.' However, it does not explicitly state whether any external calls are made, whether state changes occur, or whether authentication/costs are involved, despite the 'pay-per-call' framing.

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 tight and front-loaded: purpose, returned artifacts, and behavioral note are each in their own short sentence. There is no filler. It loses one point because 'pay-per-call tool gateway' and 'Monid' introduce jargon without clarification, which slightly hurts readability.

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

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

This tool has 9 parameters, all optional, no output schema, and no annotations. The description does not say whether the parameters are filters, examples, or entirely ignored, nor does it specify how an agent should invoke the tool (e.g., with no arguments, with one relevant field, or with all fields). The return list is useful, but the missing invocation guidance makes the definition incomplete for reliable 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 each parameter is already documented in the input schema, including discard behavior. The description adds no parameter-specific meaning, which is acceptable at the baseline 3, but it also fails to explain how the nine unrelated-looking parameters relate to finding a Monid gateway.

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: 'Find a public pay-per-call tool gateway (Monid).' It also lists the concrete return artifacts (CLI setup, how-it-works, skill file, remote MCP hops), which helps an agent understand the tool's function. However, 'Monid' is not explained and there is no explicit differentiation from the large sibling set, 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 use case is implied: call this when the user needs Monid gateway setup or remote MCP hop information. But the description gives no explicit when-to-use or when-not-to-use guidance and does not mention any alternative tools, even though there are 27 siblings with overlapping discovery/hint purposes.

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 reveals one trait ('No browser is launched'), but it does not explain whether the tool actually fetches the URL, performs a shape-only check, what constitutes 'ok', or whether side effects occur. The schema descriptions mention 'discarded after the shape check' for several params, but the main description does not convey this behavior.

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

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

The description is two short sentences with no wasted words. The core purpose is front-loaded, and the behavioral caveat ('No browser is launched') is placed immediately after, making the text efficient and easy to scan.

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

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

The description is far too short for a tool with 9 parameters, no annotations, and no output schema. It does not explain what 'ok' means, what the return value looks like, or how the multiple input types relate to the stated URL purpose. The schema fills in some gaps, but the overall tool behavior remains ambiguous.

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 meaning and in fact conflicts with the schema by implying URL-only behavior when the schema includes refs, cities, JSON, timezones, and more. The individual schema descriptions are informative, but the description does not tie them together or indicate which parameter is primary.

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

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

The description states a specific action ('Check whether a URL can be opened') and adds a key behavioral note ('No browser is launched'). However, it is misleadingly narrow: the schema accepts nine different kinds of inputs (git ref, city, JSON, timezone, etc.), so the stated URL-only purpose does not reflect the tool's actual scope. It also does not explicitly distinguish this tool from sibling tools like fetch-status or normalize-url.

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

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

There is no guidance on when to use this tool versus alternatives such as playwright-url-ok, fetch-status, or normalize-url. The phrase 'No browser is launched' implies a lightweight check, but it never states the conditions under which this tool should be preferred over other URL-related siblings.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose that the expression is 'discarded,' which is a meaningful non-persistence trait. However, it does not state whether the tool returns the computed result, a success flag, or an error, and it leaves the overall side-effect and return behavior unclear.

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

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

The description is very concise and front-loaded: 'Evaluate a+b style arithmetic' appears first and states the core purpose. The second sentence is short but meaningful, though it introduces ambiguity about what 'discarded' means. Overall, there is no wasted text.

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

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

This definition is seriously incomplete. There is no output schema, no annotations, and the description fails to explain how the arithmetic expression is supplied among nine unrelated parameters. It also omits return-value behavior and error semantics, leaving an agent unable to use the tool correctly.

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

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

Schema coverage is 100%, which normally supports a baseline of 3. But the description references an 'expression' that does not map to any of the nine schema parameters, which are ref, url, city, feed, host, json, path, and query. The description adds no usable meaning about which parameter should contain the arithmetic expression, so an agent cannot confidently invoke the tool.

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

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

The description states a specific action and resource: 'Evaluate a+b style arithmetic.' This is clear enough to distinguish calc-eval from its sibling tools, none of which suggest arithmetic evaluation. However, the phrase 'Expression discarded' adds ambiguity, and the tool description never connects the 'expression' to any 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?

Usage is implied: an agent can infer this tool is for evaluating simple arithmetic expressions. But there is no explicit guidance about when to use it versus alternatives, no prerequisite conditions, and no statement of when not to use it. The lack of any param-to-expression mapping further weakens 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?

The phrase 'Page content is not stored' adds meaningful behavioral context, especially since no annotations are present. However, it does not disclose redirect handling, timeout behavior, failure modes, or whether other inputs are retained, leaving part of the burden unmet.

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

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

The description is two short sentences with no filler. The core purpose is front-loaded, and every word contributes to understanding what the tool does.

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 optional parameters, no output schema, and no annotations, the description only conveys the primary URL-related behavior. It does not clarify how the other parameters relate to the tool or when it should be chosen over sibling tools.

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

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

Schema description coverage is high, and each parameter already has an explanatory description. The tool description adds no additional meaning beyond those structured descriptions, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb, 'Return', and names concrete outputs: host, scheme, and HTTP status for a URL. It is more useful than a tautology, though it does not explicitly differentiate itself from sibling tools like fetch-status or normalize-url.

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

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

No guidance is provided about when to use this tool versus related siblings such as web-fetch, normalize-url, or fetch-status. The description does not state exclusions, prerequisites, or context in which citation is preferred.

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

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

The description does disclose a meaningful behavioral trait: 'No identifiers are retained,' which matters for a tool that can receive refs, URLs, paths, and JSON content. However, with no annotations at all, it leaves other behavioral expectations unstated, such as whether the tool makes external calls, whether it is strictly read-only, or what the classification response contains.

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 compact and front-loaded: the first sentence gives the action, and the second provides the retention guarantee. There is no filler, though the brevity leaves substantial context to be supplied by other dimensions.

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

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

This tool has nine optional parameters, no annotations, and no output schema, so the agent needs to know what 'classified' means, what categories or output to expect, and how to choose among the many valid parameter combinations. The description only says it shows classification and retains no identifiers, which is insufficient 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 parameter names and per-parameter descriptions already carry most of the meaning; the tool description adds no parameter-level guidance. A baseline of 3 is appropriate, though the description also does not explain how the nine fields map into the classification result.

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

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

The description states a verb and object ('Show how this request is classified'), so it is not a pure tautology, but it never defines what classification scheme is used or what output the caller should expect. It also does not differentiate 'compatibility' from the many sibling shape/classifier tools such as domain-shape, validate-json, or normalize-url.

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

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

There is no when-to-use guidance, no mention of alternatives, and no exclusions. The privacy statement 'No identifiers are retained' is a useful guarantee, but it does not help an agent decide when to invoke this tool instead of one of the sibling classification 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It offers only one behavioral clue: no WHOIS or ownership data. It does not state whether the operation is purely local, whether unrelated parameters are discarded, what the return value looks like, or what happens when no valid hostname is supplied. This is insufficient for safe invocation.

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; the core verb and the key negative constraint are front-loaded. It is efficient, though its brevity is more a result of under-specification than of disciplined conciseness.

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

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

Given 9 parameters, no annotations, and no output schema, this one-sentence description is not complete enough. It does not explain what the returned labels look like, how to choose among the many parameters, whether non-host parameters are discarded, or what the tool does when multiple or no parameters are provided. The schema provides some parameter-level detail, but tool-level invocation context is missing.

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

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

All 9 parameters have descriptions in the input schema, so the baseline is 3. The tool description itself adds no parameter-level meaning and does not indicate that 'host' is the relevant parameter for this tool while the other eight are likely irrelevant or discarded. It therefore fails to bridge the mismatch between the singular 'hostname' in the description and the broad 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 verb ('Split'), a resource ('hostname'), and an output ('labels'), so an agent can tell the core operation. The phrase 'without WHOIS or ownership data' also distinguishes it from ownership-oriented domain tools. However, the input schema exposes nine unrelated parameters, and the description does not name any sibling tools, so the overall purpose 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?

Usage context is only implied. The negative clause 'without WHOIS or ownership data' hints that this is the pure-shape choice when ownership details are not needed, but it does not explicitly state when to use this tool versus alternatives like github-repo-shape, figma-url-shape, or jira-key-shape. There are no when-not conditions beyond the ownership exclusion.

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 burden. It does disclose the HTTP method (HEAD), the scope (public URL), and the output restriction (status only), which is useful safety-relevant information. However, it does not mention redirect handling, errors, timeouts, or the fact that many schema parameters are described as 'discarded' or unrelated to the stated HEAD 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 single sentence is concise, front-loaded, and contains no filler. It earns its place, though it is slightly under-sized relative to the broad nine-parameter schema and the ambiguity created by the parameter descriptions.

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 required parameters, no output schema, and no annotations. An agent cannot tell whether multiple parameters may be passed, what 'status' means for non-URL parameters, or what happens when no arguments are provided. The description is incomplete relative to the actual surface area shown in the schema.

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

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

Schema coverage is 100%, so the schema already documents all nine parameters. The description adds no per-parameter meaning, and the url parameter's description ('HTTPS URL to normalize or cite') actually conflicts with the described HEAD behavior. This is a baseline-3 case where the schema does the heavy lifting and the description adds little parameter-level clarity.

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

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

The description states a concrete action: issue a HEAD request to a public URL and return only the status. It is not a tautology and is somewhat distinguishable from content-fetching siblings like web-fetch. However, the input schema advertises nine unrelated fields (city, json, path, zone, query) and describes url as 'normalize or cite', which conflicts with the described HEAD behavior and makes the tool's actual scope unclear.

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

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

No explicit when-to-use or when-not-to-use guidance is provided, and no sibling tool is named as an alternative. The phrase 'status only' implies a lightweight HTTP-status check, but with overlapping siblings like browser-url-ok, web-fetch, and normalize-url, the agent is left to infer when this tool should be selected.

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

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

With no annotations, the description carries the full burden, but it only discloses that the path is discarded. It does not state whether the tool is a local shape check, performs any network access, what it returns, or how malformed URLs are handled.

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

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

At two short sentences, the description is concise and front-loaded with the core purpose. There is no filler, though the second fragment ('Path discarded') is cryptic and might be better expressed as part of the 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?

For an annotation-free tool with nine parameters and no output schema, this description is severely incomplete. It does not explain the return value, side effects, which parameters are relevant, or what happens when the input is not a Figma URL.

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 applies; every parameter has at least a description. The tool description adds no real mapping to those parameters, and the `url` parameter is described generically ('HTTPS URL to normalize or cite') rather than as a Figma URL, so an agent gets little help selecting the right input.

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

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

The description names a specific verb ('Parse') and a specific resource ('Figma file URL'), so an agent knows the tool is about Figma URLs. However, it does not say that the tool validates the URL's shape or differentiates itself from normalize-url/browser-url-ok, and 'Path discarded' is ambiguous.

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

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

There is no guidance on when to use this tool versus the many sibling URL/shape tools, and no exclusion criteria or alternative suggestions. The only implicit signal is the mention of Figma, which the agent must infer.

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 explicitly discloses 'No disk access', which is a useful safety-related behavioral trait. However, it does not explain what 'looks safe' means, whether it returns a boolean, or what side-effect-free guarantees exist beyond the disk-access disclaimer.

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: the main purpose appears first, followed by a key safety note. Every sentence earns its place, though the extreme brevity may undersell the tool's actual scope given 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?

Despite 100% schema coverage, the description is not contextually complete for a tool with nine parameters, no annotations, and no output schema. It does not explain why parameters like city, json, and zone belong in a path-safety check, nor what the caller should expect as a 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 all nine parameters are already documented in the schema. The tool description adds no parameter-level meaning, so the 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 clear verb and resource: 'Check whether a path looks safe', which distinguishes it from URL-focused siblings like browser-url-ok and playwright-url-ok. However, the input schema accepts many unrelated parameters (url, city, json, zone, query), creating some ambiguity about whether the tool is truly path-specific or a general shape-checker.

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 usage context is implied: use this tool when you need to verify whether a path is safe. There is no explicit guidance about when to prefer it over sibling shape-checking tools or when not to use it, so it stays at the 'implied usage' level.

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, but it only reveals that Open-Meteo is the source. It does not disclose that many schema parameters are 'discarded after' checks, whether a network call is required, or what happens on failure.

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, so it wastes no words. It is arguably too sparse for the tool's complexity, but as a concise statement it is well structured.

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

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

With 9 optional parameters, no annotations, no output schema, and 27 sibling tools, this one-sentence description is not enough to invoke the tool correctly. It omits which parameter supplies the place, the return format, error behavior, and the relationship to related 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 schema coverage is 100%, the description adds no parameter guidance. The only location-like parameter is `city`, and its schema description says it is 'discarded after the call,' leaving the agent unsure which of the 9 optional strings to populate for a place.

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 output and source: 'Latitude and longitude for a place via Open-Meteo.' This distinguishes geo-hint from weather, timezone, and URL-shape siblings. However, it never says which input identifies 'a place,' so the purpose is clear but the path to using it is not.

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, and no sibling tool is named. With 27 siblings like weather-hint, timezone, and iana-zones, an agent gets no help choosing geo-hint beyond 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 full burden of behavioral disclosure. It reveals parse intent but does not describe the return structure, invalid-URL handling, normalization behavior, or whether this is purely a validation check.

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, front-loading the core action and resource. Every word earns its place, even though the brevity contributes to incompleteness.

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, 0 required parameters, no annotations, and no output schema, one sentence is not enough. The agent does not know which parameter to pass, what the return value contains, or how invalid inputs are handled.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does add useful GitHub-specific meaning to the otherwise generic `url` parameter, but it never names `url` or clarifies why eight other optional parameters exist. The schema's 'normalize or cite' wording for `url` also creates minor semantic friction.

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'), a specific resource ('a GitHub URL'), and the expected outcome ('owner and repo'). It distinguishes this tool from sibling shape tools like figma-url-shape and jira-key-shape through the explicit GitHub focus.

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 for GitHub URLs, but it does not explicitly say when not to use it or which sibling to use for non-GitHub URLs. Given the many URL and shape-related siblings, the routing is left mostly 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 carries the behavioral burden. It does disclose a non-obvious behavior: titles are discarded, so the tool returns a count rather than story metadata. However, it does not describe return format, network dependency, or failure behavior, leaving notable gaps.

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

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

Two short sentences with the purpose front-loaded and no filler. Every word contributes: the action, the resource, and the critical output limitation are all present.

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 count tool, the core purpose is clear and invocation with no arguments is plausible. But the presence of nine unrelated optional parameters, the absence of an output schema, and no annotations leave ambiguity about invocation relevance and 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?

Schema description coverage is 100%, so the baseline is 3. The description does not add parameter-level meaning, and it leaves ambiguous whether any of the nine optional parameters are actually used or all ignored for this tool. 'Titles discarded' is output behavior, not parameter 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 states a specific action and resource: 'Count current Hacker News front-page stories.' The added 'Titles discarded' clarifies the output scope. However, it does not explicitly differentiate from sibling tools like web-fetch or normalize-url, so it stops 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?

No guidance is given about when to use this tool versus alternatives, nor any exclusions or conditions. The agent receives no help choosing between hn-front-count and siblings that might also fetch or inspect Hacker News or other URLs.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure, yet it does not say whether the call returns a list, whether it has side effects, or whether it is simply a static reference. The only weak behavioral hint is 'common', but no action or effect is 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 single sentence is clean and front-loaded with the key noun phrase, so it is not bloated. However, it is under-specified for a tool with nine parameters and no behavioral verb; brevity comes at the cost of essential guidance.

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 annotations, no output schema, and no action verb, the description is far too thin for an agent to invoke the tool confidently. It does not explain the return shape, whether arguments are needed, or how the listed parameters relate to the timezone-name 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?

Although schema coverage is reported as 100%, the parameter descriptions are unrelated to IANA timezone names: e.g., 'Git ref name; discarded after the shape check' and 'HTTPS URL to normalize or cite'. The tool description adds no explanation of which parameter, if any, influences the timezone-name output, leaving callers unable to map arguments to intent.

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

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

The description identifies a resource ('Common IANA timezone names') and a loose purpose ('for clock calls'), but it lacks a verb stating whether the tool lists, returns, or validates these names. It also fails to distinguish itself from sibling tools like 'timezone' or 'utc-time' beyond the IANA terminology.

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 some connection to clock-related tools, but there is no explicit when-to-use guidance, no exclusions, and no mention of alternatives such as 'timezone' or 'utc-time'. An agent must guess when this tool should be selected.

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 that the operation fetches a public resource and returns only group counts, which signals read-only, low-friction behavior. However, it does not mention failure modes, missing robots.txt handling, or any network dependency details.

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 meaning, and 'group counts only' gives a precise output expectation.

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 output schema, and no annotations, this minimal description leaves too much unresolved. The agent cannot confidently determine the required input or the exact structure of 'group counts,' making the definition insufficient 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?

Although schema coverage is 100%, the description does not map any parameter to the robots.txt source. The schema lists url and host but describes them as 'normalize or cite' and 'public hostname,' while seven other parameters are explicitly discarded, so an agent cannot tell which parameter to supply for the 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 names a specific verb and resource: 'Fetch a public robots.txt' and specifies the return as 'group counts only.' This is clear and distinct from general web-fetch or status-check siblings, though it does not 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 retrieving robots.txt group counts, but gives no guidance on when to prefer it over web-fetch, fetch-status, or normalize-url, and offers no exclusion criteria or alternative routing.

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

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

The phrase 'Key discarded' is a useful hint that the input is not stored or returned, but with no annotations the description must disclose the behavior more fully. It does not state whether the tool returns a boolean, throws on mismatch, or what happens when multiple schema parameters are supplied.

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

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

The two short sentences are front-loaded and contain no filler; the first states the purpose and the second adds a behavioral note. It earns brevity credit, though the lack of content prevents a perfect score.

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

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

For a simple shape-checking tool with no output schema and no annotations, the description should at least specify the expected key format, the target parameter, and the return/error behavior. It provides none of these, and the nine unrelated parameters compound the ambiguity.

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%, but the description fails to identify which of the nine parameters represents the Jira issue key. The schema describes ref, url, city, feed, host, json, path, zone, and query, none clearly related to Jira. This is misleading rather than merely incomplete.

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 essentially restates the tool name: 'Check a Jira issue key shape' adds no detail about what a valid Jira key looks like or which model input it applies to. The schema exposes nine unrelated string parameters, none labeled as a Jira key, so the stated purpose does not connect to the actual call contract.

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 sibling shape-checkers such as github-repo-shape or domain-shape, and no mention of what kinds of strings are appropriate. The only implied use is 'for a Jira key,' which is not enough given the broad, unrelated 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?

No annotations are provided, so the description carries the behavioral disclosure burden. It discloses a key behavior: only the HTTP status is returned and the body is discarded, which prevents an agent from expecting page content. It does not mention error behavior, redirects, timeouts, or the fact that the schema contains many mutually exclusive hint modes, so the disclosure is useful 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 two short sentences with no filler: the purpose is front-loaded, and the key behavioral caveat ('Body discarded') follows immediately. Every word earns its place, and the structure is easily scannable by an agent.

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

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

With nine optional parameters, no annotations, and no output schema, the description is under-specified for the full tool surface. It explains one mode (library docs URL) but not the other hint modes implied by city, json, feed, zone, or query, and it gives no details about status/error formats. The schema mitigates parameter documentation, but the description alone is not complete enough for reliable selection across the tool's full scope.

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 nine parameters have schema descriptions (100% coverage), so the baseline is 3 and the description does not need to restate them. The description adds no additional meaning about which parameter to choose; it only mentions URLs, while the schema itself documents city, json, feed, zone, query, and the rest. Thus the description does not go beyond the schema in parameter semantics.

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

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

The description states a concrete operation: return the HTTP status for a public library docs URL, and notes that the body is discarded. It is not a tautology and it is distinguishable from generic siblings like fetch-status or web-fetch by the 'public library docs URL' scope. However, the schema exposes nine unrelated parameters (city, json, feed, zone, query), so the stated purpose is narrower than the actual input surface, preventing 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 use when the agent needs an HTTP status for a public library docs URL and does not need the response body. It does not explicitly state when to prefer this tool over fetch-status, browser-url-ok, or web-fetch, nor does it give exclusions. The guidance is therefore mostly 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 carries the behavioral burden and does at least disclose that JSON values are discarded, which is useful. However, it omits important behavioral details such as whether nested keys are counted, how invalid JSON is handled, and what the return value looks like.

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

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

Two short sentences with no filler; the core action is front-loaded and the value-discarding behavior earns its place. It is concise, though slightly too terse to resolve ambiguity about nesting and error 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?

For a simple counting operation, the core behavior is captured adequately. Yet with nine parameters, no annotations, and no output schema, the description leaves open which parameter carries the JSON object, whether keys are counted recursively, and what a successful or failed invocation returns.

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

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

Since the schema describes all parameters with 100% coverage, the baseline is 3 and the description does not need to repeat parameter details. The description does not explicitly connect 'JSON object' to the json parameter, nor does it clarify how the many apparently unrelated optional parameters relate to the count, but the schema provides enough for basic use.

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 operation — count keys in a JSON object — and 'Values discarded' further narrows the behavior. It is not a tautology and is easy to distinguish from validate-json and other siblings, though no sibling is named explicitly.

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 about when to use this tool versus alternatives, no exclusion criteria, and no prerequisites. The only usage signal is implied by the name and the operation itself, so the agent receives no routing help among the many sibling tools.

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

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

With no annotations, the description carries the full burden and does disclose the key transform: query and fragment are dropped. However, it does not state whether any network fetch or URL validation occurs, leaving some ambiguity about side effects and edge cases.

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 output behavior and no filler. 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?

For a tool with a 9-parameter schema and no output schema, the description is thin: it names the output components but not the output shape, and it does not disambiguate among the many optional inputs. The rich schema partially compensates because each parameter, including `url`, is individually described.

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 schema already documents all nine parameters. The description adds the URL-processing behavior but does not explicitly direct the agent to use the `url` field and ignore the other eight optional parameters, which is a meaningful 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 names a specific operation ('Return') on a URL and the exact outputs (origin, host, path). It is clear enough to be distinguished from sibling fetch/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?

The description implies usage when a caller needs URL components, but it gives no explicit when-to-use guidance, prerequisites, or alternatives. With several URL-related sibling tools, the agent must infer the boundary.

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 only says 'No browser is launched.' It does not explain whether this performs a network request, what 'can be opened' means, whether it validates URL syntax or reachability, what it returns, or whether any side effects occur. The single behavioral clarification is useful but far from sufficient.

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 main action, and no filler. It is efficient, though the brevity leaves important semantic gaps; this is still under-specification rather than a structural problem.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, this description is incomplete. It does not connect the parameters to the operation, describe the return value, or explain the checking method, so an agent has to infer or probe to use it correctly.

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

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

Schema description coverage is 100%, so the schema already documents all nine string parameters. The tool description adds no parameter-level meaning beyond the schema, so the baseline of 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 states a clear verb and resource: 'Check whether a URL can be opened.' The added clause 'No browser is launched' helps clarify the Playwright name and distinguishes it from browser-based opening. It still does not explain what 'opened' means or how it differs from sibling tools like browser-url-ok or fetch-status, 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 guidance on when to choose this tool over browser-url-ok, fetch-status, web-fetch, or normalize-url. 'No browser is launched' hints at a lightweight/headless context but does not state conditions, exclusions, or alternatives.

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

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

With no annotations, the description carries the burden of behavioral disclosure. 'Query discarded' usefully signals non-retention of the input. However, it does not describe what happens when the query parameter is absent or confirm the exact return value beyond the implied 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?

Two short sentences with no filler and the action is front-loaded. The second sentence adds a useful retention detail, so both sentences earn their 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 exposes nine optional parameters and has no output schema, but the description only addresses 'query'. The role of the other eight parameters is unexplained, and the result format is not explicitly stated, leaving the agent to infer too much.

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

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

Schema description coverage is 100%, so the parameters are already documented in the schema. The description adds no parameter-specific detail and does not tell the agent which parameter is the query, though the schema's 'query' field does.

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: count characters in a search query. This separates it from sibling validators like browser-url-ok or validate-json. It does not name the query parameter or explicitly state the return type, 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?

No guidance is given on when to choose this tool over siblings such as memory-key-count or validate-json. The intended use is only implied by the verb 'count'; there are no exclusions, prerequisites, or alternative-selection cues.

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 full responsibility for disclosing behavior. The description only says it is a 'short catalog'; it does not mention side effects, return value shape, input handling, or any operational characteristics. The schema's 'discarded' hints are not part of 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 description is short, but it is under-specified rather than appropriately concise. The single sentence does not earn its place because it adds almost no operational information beyond the tool name.

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

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

With nine optional parameters, no output schema, no annotations, and no usage context, a one-clause description is completely inadequate. An agent cannot determine what inputs are relevant, what the tool returns, or when to prefer it over related sibling tools.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description itself adds no parameter meaning, but the schema already documents each of the nine optional parameters, so the description does not need to repeat them.

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

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

The description is essentially a noun phrase restating the tool name: 'status-catalog' becomes 'Short catalog of common HTTP status codes.' It does not state an action or method, and it does not differentiate this from siblings like fetch-status, browser-url-ok, or web-fetch.

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

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

There is no guidance about when to use this tool versus alternatives. No when-to-use, no exclusions, and no mention of any sibling tool despite the large list of potentially related 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 behavioral disclosure burden. It does reveal one key trait: the prompt is discarded. However, it does not clarify whether the nine input parameters affect the result, what the returned template contains, or whether the tool has 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 with the primary action front-loaded. Every sentence earns its place: the first states what it returns, the second warns that the prompt is ignored. No filler or redundancy.

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

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

For a simple template-returning tool, the description gives the core purpose and a key behavioral caveat. Still, with no output schema and no annotations, it leaves some ambiguity about how the nine optional parameters relate to the output and when to prefer this tool over the many 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 input schema already describes all parameters with high coverage, so the description does not need to repeat them. The description adds no parameter-level meaning beyond the schema, which is acceptable given the 100% schema description coverage.

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

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

The description clearly states the verb and deliverable: 'Return a three-step thinking template.' It is specific enough for an agent to know the tool produces a fixed template rather than performing a data operation, though it does not explicitly contrast with sibling shape-checker and hint 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 intended use is implied: call this tool when a three-step thinking template is needed. 'Prompt discarded' provides an important constraint, but the description does not explicitly state when to use this tool versus 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?

No annotations are provided, so the description carries the full burden of disclosing behavior. It only says what the tool returns, but does not describe output format, error handling for invalid timezone names, network dependencies, or any side effects. It implies a read operation but omits most 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, front-loaded sentence with no wasted words. However, it is so terse that it omits critical usage and parameter mapping information, so the compactness is not fully appropriate for the tool's needs.

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, and the description fails to connect the IANA timezone purpose to any parameter in the input schema. An agent cannot reliably determine how to specify the timezone or what the response format will be, so the definition is incomplete.

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 high parameter description coverage, the visible schema exposes parameters like ref, url, city, feed, host, json, path, and query, none of which clearly accepts an IANA timezone. The description does not help the agent map the required timezone name to any parameter, making 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 states a specific verb and resource: 'current time in a named IANA timezone.' It clearly differentiates from sibling tools such as utc-time and iana-zones by specifying IANA-zone lookup rather than UTC time or zone listings.

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 when-to-use guidance, no comparison to alternatives, and no conditions for choosing this tool over utc-time or iana-zones. The agent is left to infer usage from the name and siblings rather than from the 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?

With no annotations, the description carries full responsibility for disclosing behavior. It does not mention that the tool accepts and discards parameters, has no side effects, or returns a timestamp format. The unusual input schema (URLs, cities, JSON, paths) is completely unexplained, leaving the agent in the dark about how the tool actually behaves.

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 phrase with zero wasted words. It is appropriately sized for a tool with such a simple purpose, even though it sacrifices contextual 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?

The tool appears trivial, but the presence of seven unrelated, optional-looking parameters makes the description inadequate. An agent cannot tell whether any parameter is required, why they exist, or whether the tool returns something beyond a timestamp. The lack of an output schema and any note about parameter handling leaves significant ambiguity for a tool that should be one line.

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 descriptions are unusually detailed, explicitly stating that each property is 'discarded' after the call or check, so schema coverage is effectively 100%. The description adds no additional meaning about how parameters relate to the tool's function, but the schema itself supplies the necessary semantics, yielding the baseline score.

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

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

The description 'Current UTC timestamp' states a specific resource (UTC timestamp) and an implied verb (return/provide), making the primary action clear. It is naturally distinguished from siblings like 'timezone' and 'iana-zones', though it does not explicitly name 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?

There is no guidance about when to use this tool versus alternatives like 'timezone' or 'calc-eval', nor does it mention that the tool ignores all input parameters. An agent must infer the intended use from the name and one-line description 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?

With no annotations provided, the description carries the full disclosure burden. It does disclose an important behavioral trait: the body is discarded, implying no persistence and a read-only intent. However, it does not state what happens on invalid JSON (e.g., whether the tool returns a boolean, throws, or produces an error response), which is a notable 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 two short sentences with zero filler. It front-loads the core purpose and immediately adds the key behavioral caveat, making it highly efficient for an agent to parse.

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

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

The tool has 9 optional parameters and no output schema, yet the description only references a generic 'body' without mapping it to the `json` parameter or describing the result of the check. The many unrelated-looking parameters (city, feed, host, path, etc.) create confusion that the description does not resolve, and the absence of return-value details leaves the agent guessing about invocation outcomes.

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 schema already documents each parameter, including the `json` parameter as 'JSON text to validate; discarded after the check'. The description itself adds no additional parameter meaning, so it neither helps nor harms beyond the schema.

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

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

The description uses a specific verb ('Check') and resource ('whether a body is valid JSON'), making the tool's purpose immediately clear. It is distinct from sibling shape-checkers like file-path-ok or domain-shape because JSON validation is a visibly different concern. The extra note that the body is discarded reinforces scope without 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 description implies the natural usage context: use this tool when you need to validate whether some body is valid JSON. However, it does not explicitly state when not to use it or mention any alternative tools, leaving the agent to infer routing from the tool name alone.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states that the tool provides a temperature via Open-Meteo, but it does not disclose that this is an external network call, what happens if the city is not found, or that most schema parameters appear to be ignored or discarded. The parameter descriptions in the schema hint at discard behavior, but the tool description itself does not.

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

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

The description is a single, front-loaded sentence with no wasted words. It immediately states the tool's purpose and source. Its brevity is efficient, even if other dimensions suffer from the lack of 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?

The tool has nine parameters, no required fields, no annotations, and no output schema. The description is too sparse to guide an agent about which parameters are relevant or what the response looks like. The schema helps, but the description does not reduce the confusion caused by a large set of seemingly unrelated parameters like ref, url, feed, host, json, path, zone, and query.

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 emphasis on 'city' as the meaningful parameter, which is helpful, but it does not explain the relationship between the other eight schema parameters and the weather functionality. Since the schema already describes each parameter clearly, the description adds little beyond what is structured.

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

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

The description clearly identifies the tool's function: retrieving the current temperature for a city via Open-Meteo. It names a specific resource and source, and the tool name weather-hint matches the description. However, it lacks an explicit verb like 'get' or 'retrieve' and does not contrast with sibling tools such as geo-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 implies a use case—when you need a city's current temperature—but gives no guidance on when to prefer this tool over alternatives like geo-hint or web-fetch. There are no exclusions, prerequisites, or notes about the many other schema parameters and whether they should be 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 discloses meaningful behaviors: it returns only HTTP status and content type, discards the body, and is scoped to public URLs. However, with no annotations, it omits details like redirect handling, error responses, or any side effects, leaving the agent partially informed.

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 short clauses, both information-dense and front-loaded. It conveys the core operation and the key body-discarded caveat with zero filler.

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

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

The description is insufficient for the tool's complexity: 9 parameters, no annotations, no output schema, and many similar siblings. It does not explain the purpose of the eight auxiliary parameters, return format details, or how this tool differs from related fetch/status 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?

The input schema has 100% description coverage for all 9 parameters, so the schema already documents each parameter. The description adds no additional parameter-specific meaning, which is acceptable given the schema coverage.

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

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

The description clearly states the verb/resource outcome: returns HTTP status and content type for a public URL. It is specific and easy to understand, but it does not explicitly distinguish itself from sibling tools like fetch-status or browser-url-ok.

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

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

No usage guidance is provided. There is no mention of when to prefer web-fetch over similar siblings such as fetch-status, browser-url-ok, or normalize-url, and no exclusions or alternative routing.

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

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

There are no annotations, so the description carries the behavioral burden. It does disclose that the title is discarded after the call, and 'check' implies a read-only operation, but it does not state the return format, error behavior, or whether a network request is made.

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 short sentences with no filler or repetition. The core purpose is front-loaded, and the discard note adds a meaningful behavioral detail without bloating the text.

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, no annotations, a large heterogeneous input schema, and a description that refers to a nonexistent 'title' parameter, the definition is not complete enough for correct invocation. It needs to identify the input field, state the return type, and cover side effects or exclusions.

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

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

The schema contains eleven parameters, but none of them is named 'title', and the description does not map 'Wikipedia title' to any existing property. Despite detailed per-parameter descriptions, the agent cannot determine which field should receive the title, so the description actively fails to clarify the central input.

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

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

The description states a specific verb ('check'), a specific resource ('Wikipedia title'), and the expected outcome ('exists'). This makes it clearly distinguishable from sibling tools like normalize-url, validate-json, and domain-shape.

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

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

The description gives no guidance about when to prefer this tool over sibling lookup/validation tools such as browser-url-ok or fetch-status. Usage must be inferred entirely from the name and purpose, with no exclusions or alternatives mentioned.

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