ISO country NI

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

With no annotations, the description carries the behavioral burden. It adds one meaningful disclosure ('Task text discarded') and implies a read-only lookup, but it does not mention authentication, network access, cost implications of 'pay-per-call', or whether it modifies anything.

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

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

Three short sentences with purpose first and no filler. It uses unexplained jargon ('Monid', 'MCP hops') but otherwise every sentence earns its place.

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

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

For a tool with 9 optional parameters, no output schema, no annotations, and 27 siblings, the description leaves the invocation pattern and return format underspecified. An agent cannot tell whether it should pass a URL, city, or nothing, or when to prefer this tool over related hints/validators.

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-level coverage is 100%, the description does not connect any of the nine optional parameters to the stated purpose of finding a Monid gateway. Each parameter is described individually in the schema, but their relationship to CLI setup/MCP hops is unclear; the tool can be invoked with no required params, yet the description never says that.

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 and object ('Find a public pay-per-call tool gateway (Monid)') and lists concrete outputs (CLI setup, how-it-works, skill file, remote MCP hops). It does not explicitly contrast with siblings, and 'Monid'/'MCP hops' are unexplained, 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?

Usage context is implied: call this when the agent needs the Monid gateway setup or pay-per-call tool routing. There are no when-not-to-use statements or alternative sibling tools named, so guidance 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 available, the description carries the burden of behavioral disclosure. It does disclose a meaningful side-effect: no browser is launched. However, it does not describe what happens when the URL cannot be opened, whether a network request is made, or what kind of result is returned.

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

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

The description is two short, front-loaded sentences with no filler. 'No browser is launched' earns its place by preventing confusion with browser-based alternatives.

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 seven input parameters and has no output schema or annotations, yet the description says nothing about which parameters matter, what a successful check returns, or how failures are reported. An agent can likely guess the basic url case but has no grounding for edge cases or the broader 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 already has descriptions for all seven parameters, so schema description coverage is high and the baseline applies. The description adds only the notion of URL checking but does not explain how the many non-URL parameters relate to the tool; the schema's own 'url' description is also oddly focused on normalization/citation rather than checking openness.

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 addition 'No browser is launched' helps distinguish it from browser-dependent siblings such as playwright-url-ok, though it does not explicitly name that alternative or clarify what 'opened' means (syntactic validity vs. actual reachability).

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 'No browser is launched' sentence provides an implicit usage signal that this is a lightweight or non-browser option. However, there is no explicit guidance about when to use this tool versus fetch-status, web-fetch, or normalize-url, so the routing context is only implied rather than stated.

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

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

No annotations are provided, so the description must carry the full behavioral disclosure burden. The only behavioral trait disclosed is 'Expression discarded', which addresses data retention but not whether evaluation is read-only, what the return value is, how errors are handled, or what happens with the other nine schema parameters.

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

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

The description is just two short sentences with no filler: the purpose and the discard behavior are front-loaded. However, the extreme brevity contributes to the lack of necessary input and usage 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 no annotations, no output schema, nine parameters, and many siblings, this definition is far from complete. It does not explain how to supply an expression, what result is returned, when to use it, or how the other parameters relate, so an agent cannot call it correctly from the provided information.

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

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

The schema descriptions cover all nine parameters, so the baseline is 3, but the description introduces an 'expression' input that has no corresponding property. Because additionalProperties is false, an agent cannot determine how to pass 'a+b' to this tool, making the description actively confusing rather than additive.

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, 'Evaluate a+b style arithmetic', which suggests a calculator tool, but it does not map to any input field: none of the nine schema properties (ref, url, city, feed, host, json, path, zone, query) represents an arithmetic expression, and additionalProperties is false. This makes the stated purpose effectively unusable and inconsistent with the schema.

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

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

There is no guidance about when to use calc-eval versus any of the many sibling tools, such as domain-shape, validate-json, timezone, or normalize-url. The description provides no context, prerequisites, alternatives, or exclusions, and all parameters are optional, so an agent has no signal for selecting 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?

Annotations are absent, so the description carries the burden. It adds one useful behavioral guarantee ('Page content is not stored'), which signals a privacy-safe read operation. However, it does not disclose whether a network fetch occurs, what side effects exist, or how errors 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?

Two short sentences, with the primary return behavior front-loaded and the privacy guarantee as a single clarifying second sentence. 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?

With nine optional-looking parameters, no required fields, no output schema, and no mention of which parameter is actually needed, the description is incomplete for invocation. An agent cannot tell whether 'url' must be supplied or how the returned host, scheme, and HTTP status are represented.

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 nine parameters with 100% coverage, including explicit notes that many are 'discarded after' the check. The description adds no parameter-specific meaning beyond naming 'URL', 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 clearly states a specific verb ('Return') and resource ('URL'), and names the three outputs: host, scheme, and HTTP status. It does not explicitly differentiate from overlapping siblings like fetch-status or normalize-url, so it loses the top score.

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

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

There is no guidance about when to use this tool versus siblings such as fetch-status, normalize-url, or web-fetch. No exclusions, prerequisites, or alternative tool names are mentioned, so an agent must infer the right context.

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

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

With no annotations, the description carries the behavioral disclosure burden. It adds one useful privacy trait, 'No identifiers are retained,' and the schema descriptions reinforce 'discarded' for several fields. However, it does not disclose the return format, whether any external calls occur, or any other side effects, so behavioral transparency is only partial.

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

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

The description is concise and front-loaded with the core action. It is also overly terse for a tool with nine parameters and many siblings, and the privacy sentence is policy rather than actionable usage 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?

The description is inadequate for a tool with nine optional parameters, no output schema, and no annotation support. It does not explain how the classification is returned, how to choose the right parameter, or how this tool relates to the 27 sibling tools. An agent cannot reliably select and invoke it based on the description alone.

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

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

Schema coverage is 100%, and each parameter already has a descriptive comment such as 'Git ref name; discarded after the shape check.' The tool description adds no parameter-specific meaning, so it meets the baseline but does not enhance 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 says 'Show how this request is classified,' which names an action and an object, but it never defines what classifications exist, what inputs drive them, or how this differs from sibling tools like browser-url-ok or validate-json. The purpose remains vague and does not distinguish the tool from its many alternatives.

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

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

No guidance is given about when to use compatibility instead of the sibling-specific tools. The description does not explain which parameter to supply, what request shapes are supported, or when a direct check like normalize-url or validate-json would be more appropriate. Usage must be inferred entirely from the schema and tool name.

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

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

With no annotations, the description bears the burden of explaining side effects; it discloses that the operation is a local split and explicitly excludes WHOIS/ownership lookup, which is useful. It stops short of stating whether the tool performs any network access, what it returns, or that unrelated parameters are discarded, so transparency is only partial.

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

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

The description is a single sentence with no filler and front-loads the action and object. It is concise, but it is arguably too sparse for a nine-parameter tool, so it earns a 4 rather than a 5.

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 the definition needs more context than one sentence. The description covers only hostname splitting and omits the return format, how to choose among parameters, and any safety or exclusion guidance beyond WHOIS/ownership, leaving significant gaps.

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

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

Schema coverage is 100%, so the baseline is 3; each parameter already has its own description in the schema, including discard behavior. The top-level description adds no parameter guidance and does not clarify which of the nine optional fields should be supplied for a hostname split, though the schema's 'host' description 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 names a concrete operation ('Split a hostname into labels') and a clear negative boundary ('without WHOIS or ownership data'), so an agent can tell this apart from an ownership-lookup tool. It does not, however, explain the relationship to the eight other parameters in the schema or to the sibling shape tools, so it is clear but not fully differentiating.

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 it when you need hostname labels rather than WHOIS or ownership details. It does not name alternatives such as normalize-url or browser-url-ok, nor does it give an explicit when-to-use/when-not-to-use rule, leaving the agent to 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?

The description discloses the request method (HEAD) and the limited output (status only), which is useful behavior. With no annotations, it carries the full burden, but it is silent on redirects, errors, timeouts, response format, and how the schema's unrelated parameters 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?

The description is a single sentence with no filler, front-loading the HTTP method and the tool's scope. Every word contributes to understanding the operation.

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

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

For a tool with 9 optional parameters, no output schema, and no annotations, the one-line description is thin. It leaves ambiguity about which parameter to pass for the HEAD request, what the returned status looks like, and whether the other parameters are relevant. High schema coverage prevents it from being severely 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?

Schema description coverage is 100%, so the schema already documents every parameter. The description adds no parameter-level detail beyond implying that the url parameter is central to the HEAD request.

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 ('HEAD'), a target ('a public URL'), and an output constraint ('status only'), making the core function clear. It does not name sibling tools or clarify why the schema contains many seemingly unrelated parameters, but the main purpose is unambiguous.

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

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

The phrases 'public URL' and 'status only' imply this is for lightweight public status checks and not for fetching content. However, there is no explicit when-to-use guidance or comparison to alternatives like web-fetch, browser-url-ok, or playwright-url-ok.

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 that the path is discarded; it does not say whether the URL is validated, normalized, or what the result of the parse looks like, and there is no output schema to fill that 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 very short, front-loaded with the core purpose, and contains no filler. The 'Path discarded' fragment is efficient but could be clearer, so it does not quite earn a 5.

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

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

With nine parameters, no output schema, and no annotations, a six-word description is insufficient for an agent to confidently invoke the tool correctly. It does not explain the expected return value, which parameters are relevant to a Figma URL parse, or how the many unrelated parameters should be treated.

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 schema already documents all nine parameters. The description adds no meaningful parameter semantics beyond the schema, and the ambiguous 'Path discarded' does not clarify which parameter is actually used or ignored.

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

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

States a specific verb and resource ('Parse a Figma file URL.'), which clearly identifies the tool's target and differentiates it from siblings like normalize-url or browser-url-ok. However, the appended 'Path discarded' is ambiguous—it could refer to the URL path or the `path` parameter—which slightly muddies an otherwise clear purpose.

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

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

The description implies the tool is for Figma file URLs, but it provides no explicit when-to-use guidance or exclusions. It does not name alternatives or explain when another URL-handling sibling would be more appropriate, so an agent must rely mostly on the tool name and context.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It usefully reveals that no disk access occurs, which is an important safety trait. However, it leaves 'safe' undefined and says nothing about the response shape or what kinds of path hazards are checked.

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

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

Two short sentences, front-loaded with the core action and an immediately useful safety qualifier. There is no redundant or filler 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?

For a tool with nine optional parameters, no annotations, and no output schema, this one-line description is incomplete. An agent cannot tell what 'safe' means, what result is returned, or whether only the path parameter is relevant to this tool. More guidance is needed 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 description coverage is 100%, so the schema already documents all nine optional parameters, including 'File path to check.' The description adds no parameter-level meaning beyond the schema and does not explain why unrelated parameters like url, city, feed, and query are present.

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

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

The description states a specific verb and resource: 'Check whether a path looks safe' and adds the useful qualifier 'No disk access.' It is clear, but it does not explicitly differentiate itself from sibling tools like wiki-title-ok or browser-url-ok, 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 when-to-use or when-not-to-use guidance is provided. The 'No disk access' phrase hints that this is a lightweight syntactic check, but the description never names an alternative tool or gives conditions that should route an agent elsewhere.

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 is the sole source of behavioral disclosure. It reveals an external dependency on Open-Meteo but does not state the output format, error behavior, latency, or that certain inputs are discarded after the call.

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

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

The description is a single, front-loaded sentence with no redundant wording. It is concise, though arguably too sparse for a tool with nine parameters and no annotations.

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

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

For a tool with no annotations, no output schema, and nine optional parameters, one sentence stating the core purpose is not complete. An agent cannot confidently determine which parameter to populate 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?

The input schema already documents all nine parameters, so the baseline is 3. The description adds no mapping between 'a place' and a specific parameter such as city or query, leaving some semantic ambiguity despite 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 sentence conveys that the tool returns latitude and longitude for a place and names Open-Meteo as the data source, which distinguishes it from siblings like weather-hint and timezone. It lacks an explicit verb like 'get' or 'return' and never says which input parameter supplies the place, so it is not a perfect 5.

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

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

There is no guidance about when to use geo-hint versus alternatives such as weather-hint or timezone, and no mention of prerequisites (e.g., a city name). The only implicit trigger is 'a place,' which is too vague for a tool with nine optional parameters.

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

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

No annotations are provided, so the description must carry the behavioral burden. It says the tool parses owner/repo, but it does not disclose whether the call is read-only, what gets returned for invalid URLs, or that many schema parameters are discarded. The 'discarded' hints live in the schema, not 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 description is a single concise sentence with no filler or repetition. It is front-loaded and immediately actionable. It is not penalized heavily for brevity, though it could include a bit more structure around inputs and outputs.

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 having nine parameters, no output schema, and no annotations, the description only covers one simple use case. It omits the return value shape, error behavior, and which inputs are relevant. This is inadequate for an agent to confidently select and invoke the tool for the full range of inputs the schema accepts.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds some meaning by implying that `url` is the key input for extracting owner and repo, but it never explicitly names the parameter nor explains the role of the other eight parameters. The schema descriptions already cover each parameter, so the description's added value is limited.

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 ('Parse'), the resource ('GitHub URL'), and the expected result ('owner and repo'). It differentiates from sibling URL tools like normalize-url or fetch-status by naming GitHub repo parsing specifically. It loses a point because it doesn't mention the tool's broader shape-checking behavior implied by the schema.

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

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

There is no guidance about when to use this tool versus alternatives such as normalize-url, domain-shape, or figma-url-shape. The description implies a use case but provides no exclusions, no prerequisite context, and no comparison to other URL-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 add useful behavior by stating 'Titles discarded,' which tells the agent not to expect titles in the result. However, it does not disclose whether a live network fetch occurs, what the output format is, or any side effects or rate-limit implications.

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, with the main action in the first sentence. It is slightly too terse for a tool with 9 optional parameters and no annotations, but it has no wasted words.

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 9-parameter tool with no annotations and no output schema, this description is incomplete. It does not explain which parameters are relevant, whether the tool requires any arguments, whether it performs a live Hacker News request, or what the successful response looks like beyond implying a count.

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

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

The input schema already documents all 9 parameters with descriptions, so the baseline is 3. The tool description itself does not connect any parameter to the HN counting task, and 'Titles discarded' only weakly mirrors the feed parameter's schema note rather than helping an agent select or fill arguments.

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.' It does not explicitly contrast with sibling tools, so it stops short of full sibling differentiation, but the HN-specific target is distinctive enough to separate it from most other tools in the list.

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 web-fetch, wiki-title-ok, or fetch-status. The phrase 'Titles discarded' notes a limitation but does not give an explicit when-to-use or when-not-to-use recommendation.

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

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

With no annotations provided, the description carries the full behavioral burden. It does add some behavioral context by limiting the scope to 'Common' zones and framing the tool as a helper for clock calls. However, it does not state the return format, that this is a read-only list operation, or that the many accepted parameters are effectively discarded/ignored.

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

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

The description is a single sentence with no filler; every word contributes meaning, and the core resource is front-loaded. It is appropriately minimal for what appears to be a simple data-lookup/helper tool.

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

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

The description is too thin given the tool's nine optional parameters and lack of an output schema. It leaves unexplained why a timezone-name listing tool accepts fields like 'ref', 'url', 'city', 'feed', 'host', 'json', and 'path', and it never states what a call returns (e.g., a list of strings, newline-delimited, etc.), so an agent cannot confidently predict the result.

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

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

Schema description coverage is 100%, so the baseline of 3 applies even though the tool description adds no parameter-level detail. The schema already documents each optional string field, including notes about values being discarded after shape checks or normalization.

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 resource ('Common IANA timezone names') and its intended context ('for clock calls'), so an agent can tell this is a lookup of timezone identifiers rather than a clock conversion operation. It lacks an explicit verb like 'lists' or 'returns', and it does not name sibling tools, so it falls just short of a top score.

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

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

The phrase 'for clock calls' implies the usage scenario: use this tool when you need timezone names for clock-related operations such as the sibling 'timezone' or 'utc-time' tools. However, it does not explicitly state when to use it versus alternatives, nor does it mention exclusions or prerequisites.

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 supplied, the description carries the full disclosure burden, but it only says the tool fetches and returns counts. It does not explain which parameter selects the target, that unrelated inputs are discarded, or any network/error behavior. The schema's 'discarded after' hints are not reconciled in 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 description is a single front-loaded sentence with an active verb, a clear object, and a stated output constraint. There is no filler or redundant repetition of the tool name.

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

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

For a tool with nine optional parameters and no output schema or annotations, the description is incomplete. It fails to say which parameter supplies the robots.txt URL, what happens when multiple parameters are provided, or what the group-count result looks like beyond the vague phrase 'group counts only'.

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

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

Although schema description coverage is 100% (baseline 3), the description does not connect any of the nine optional parameters to the robots.txt fetch. Schema fields like url, host, feed, and json have unrelated descriptions, and none mentions robots.txt, so the agent cannot tell 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 uses a specific verb and resource ('Fetch a public robots.txt') and states the precise output ('return group counts only'). This makes the tool's narrow purpose clear and distinguishes it from generic siblings like web-fetch or fetch-status, 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 phrase 'group counts only' implies the tool is for obtaining robots.txt group counts rather than full content, but it provides no explicit when-to-use/when-not-to-use guidance and does not point to an alternative sibling. Usage context is only implied, not stated.

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. The only behavioral claim is 'Key discarded,' which is vague because no parameter named 'key' exists in the schema; it also does not disclose output format, side effects, or whether anything is returned.

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

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

The description is short and the main purpose is front-loaded, which is efficient. However, the second sentence 'Key discarded' is unclear and does not help an agent invoke the tool, making the description feel under-specified rather than 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?

For a tool with nine parameters, no output schema, and no annotations, this description is far too thin. An agent cannot determine which parameter to pass, what the tool returns, or how it differs from sibling shape-checking 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 input schema already documents all nine parameters. The description adds no parameter-level meaning and introduces an ambiguous 'key' term that does not map cleanly to any property in the schema.

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

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

The description states a specific verb and resource: check the shape of a Jira issue key. This distinguishes it from other shape-checking siblings like github-repo-shape or domain-shape. However, it does not say what a positive or negative result looks like, and no parameter named 'key' appears in the schema.

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

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

The phrase 'Jira issue key' implies the tool is for validating Jira issue key shapes, so basic usage context is present. But the description gives no explicit when-to-use versus when-not-to-use guidance and names no alternatives or 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?

With no annotations provided, the description carries the behavioral burden. It usefully discloses that the body is discarded and that only HTTP status is relevant, which helps an agent set expectations. However, it does not mention side effects, read-only status, redirect behavior, or rate limits, so transparency is only partial.

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

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

The description is two short sentences with no unnecessary wording. The core purpose is front-loaded, and the second sentence adds a meaningful behavioral constraint about the body being discarded.

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

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

For a tool with 9 optional parameters and no output schema or annotations, the description is too thin. It only mentions a docs URL while the schema exposes unrelated parameters like city, zone, json, and query, and it does not clarify which parameter to supply or how this relates to overlapping 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 input schema already documents all 9 parameters. The tool description adds no parameter-level meaning beyond the schema, so it stays at the schema-covered baseline.

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

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

The description clearly states the tool returns HTTP status for a public library docs URL and adds that the body is discarded. This is a specific purpose and not a tautology, though it does not explicitly differentiate from siblings 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?

There is no guidance about when to use this tool versus alternatives such as fetch-status, browser-url-ok, or normalize-url. The 'Body discarded' note implies body content is unavailable, but it does not state when to choose this tool or when to avoid 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?

With no annotations provided, the description carries the behavioral burden. 'Values discarded' is a useful disclosure, and counting is an inherently read-only-sounding operation. However, it does not disclose return format, whether keys are counted recursively or top-level, behavior on invalid JSON, or any memory-related side effects hinted at by the tool name.

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

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

Two short sentences with no filler, redundancy, or unnecessary details. The core verb and resource are front-loaded, and every word contributes to the meaning.

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

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

The tool has no output schema and no annotations, so the description must explain the return value and input contract. It only says 'Count keys in a JSON object' and never states what the output looks like, which input parameter to use, or how the memory-related name maps to the JSON-object behavior. That is too thin for a nine-parameter 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?

Schema description coverage is 100%, so the baseline is 3 even though the description adds little parameter-specific detail. The description's 'values discarded' does clarify how parameter values are treated, but it does not identify which parameter is the JSON object or explain how the other eight parameters relate to the count.

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 keys in a JSON object.' This is clear and distinguishes it from validation tools like validate-json. However, it does not say which of the nine schema parameters is the JSON object to count, and it does not explicitly differentiate from sibling count-like 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 alternatives, no stated prerequisites, and no exclusions. The description only states what the tool does, not when it 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?

The description discloses that query and fragment are dropped, and 'Return' implies a read-only transformation. However, there are no annotations, and the description does not mention the HTTPS-only requirement (only visible in the schema), error handling, or the fact that all parameters other than `url` are effectively ignored. This is partial transparency.

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

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

The description is two terse sentences with no filler, and the core operation is front-loaded. Every sentence earns its place, making it highly 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?

The definition is incomplete for correct invocation. There is no output schema, and the description does not specify the return format (e.g., object keys or string template). It also fails to explain why eight optional parameters exist or that they should be omitted, and it leaves the HTTPS-only restriction to the schema rather than the description.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaning for the `url` parameter by saying query and fragment are dropped, but it does not explain the eight unrelated parameters; their schema descriptions say they are discarded, which is already structured information.

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

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

The description states a specific verb ('Return') and resource ('origin, host, and path for a URL'), and it adds the behavioral detail that query and fragment are dropped. It is clear about the core operation, but it does not explicitly differentiate this tool from siblings like domain-shape or browser-url-ok, so it stops short of full distinction.

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

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

No guidance is given for when to use this tool versus alternatives. There are no mentions of alternatives, exclusions, or conditions. The schema's many unrelated optional parameters add confusion about which parameter to supply, and the description does not clarify that only `url` is relevant.

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 one behavioral trait—no browser launch—but with no annotations, it carries the full burden of behavioral disclosure. It does not mention whether a network request is made, whether the check is synchronous, what response is returned, or what side effects (e.g., caching, logging) may occur.

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

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

The description is two short sentences with no filler. The core purpose is front-loaded, and the clarifying note about no browser launch is immediately useful and 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?

For a 9-parameter tool with no output schema and no annotations, this description is incomplete. It does not explain which parameter is relevant to the check, how the other parameters behave, or what the tool returns. An agent would be uncertain about the tool's full behavior and result format.

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 9 parameters already have individual descriptions. The tool description itself adds no parameter-level meaning, but because the schema covers all parameters, 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 states a specific action—'Check whether a URL can be opened'—and adds a clarifying constraint, 'No browser is launched.' This gives the basic purpose, but 'can be opened' is somewhat ambiguous (network reachability vs. URL format), and it does not explicitly distinguish the tool from siblings like browser-url-ok or fetch-status.

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

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

There is no guidance on when to use this tool versus alternatives such as browser-url-ok, fetch-status, or web-fetch. 'No browser is launched' hints at a contrast with browser-based checks, but no explicit when-to-use or when-not-to-use guidance is 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?

No annotations are present, so the description carries the full behavioral burden. It does disclose that the query is discarded, which is a useful privacy/retention detail, but it does not state the return format, whether other parameters are ignored, or any potential side effects. The disclosure is helpful 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?

Two short, front-loaded sentences with no redundant wording. The first sentence states the operation, and the second adds a meaningful privacy/retention note.

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, this description is incomplete. It does not identify which parameter is the operative one (the schema does), does not describe the return value, and leaves the presence of eight unrelated parameters unexplained.

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 provides 100% description coverage for all nine parameters, including 'Search text; discarded after the length check' for the query parameter. The description adds no parameter-specific 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 specific action ('Count characters') applied to a specific resource ('a search query'), which clearly distinguishes it from sibling count/shape tools such as memory-key-count and web-fetch. The tool name reinforces the same purpose.

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

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

The intended use is implied: call this when the user needs the character count of a search query. However, there is no explicit statement of when not to use it, no mention of alternatives, and no exclusions beyond the narrow scope implied by the name.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, and it only says the tool is a catalog. It does not state whether the tool makes network requests, whether inputs are ignored, whether it is a static reference, or what side effects might occur. The schema hints that values are discarded, but that information is not in 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 description is a single short sentence with no wasted words, which is structurally efficient. However, it is so skeletal that it under-specifies the tool rather than being appropriately concise. It lacks any organizing context for the large 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?

For a tool with seven parameters, no annotations, and no output schema, this description is not complete enough for an agent to invoke it correctly. The relationship between the catalog and the parameters is entirely unexplained. An agent is left without enough information to know what inputs are valid or what the tool 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?

The input schema has descriptions for all seven parameters, so schema coverage is high and the baseline is 3. The description adds no parameter-level meaning, and it fails to explain how any of the parameters relate to looking up HTTP status codes. Still, the schema itself provides detailed per-parameter 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 says the tool provides a short catalog of common HTTP status codes, which conveys the resource but not an explicit action or invocation model. It does not distinguish itself from siblings like fetch-status in terms of when to use the catalog rather than a live check. The name and description together give a rough idea, but the purpose remains vague.

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

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

There is no guidance about when to use this tool instead of alternatives such as fetch-status, nor any indication of which of the seven input parameters to provide. No exclusions or context are given. An agent cannot determine whether to call it with no arguments or with a specific reference value.

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. It usefully reveals that the prompt is discarded, signaling that inputs won't drive actual reasoning. However, it does not clarify that all arguments are ignored, whether the template is static, or what side effects (if any) exist.

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

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

The description is two short sentences with the main action front-loaded and no filler. 'Prompt discarded' is meaningful but slightly cryptic, which 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 tool with no annotations, no output schema, and nine optional parameters, the description is too sparse. It does not describe the contents of the three-step template, whether all parameters are ignored, or how this tool relates to sibling validation 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% and each parameter already has an individual description, including discard behavior. The tool description adds no parameter-level semantics beyond the schema, 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 states a concrete action and deliverable: 'Return a three-step thinking template.' This is enough to identify what the tool produces, though it does not explicitly differentiate it from sibling tools or explain why 'prompt' is discarded.

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 think-steps versus the many sibling tools, no exclusions, and no situational context. The only usable hint is the tool name and the word 'template,' so usage must be inferred.

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 says 'Current time in a named IANA timezone' and does not mention side effects, discarded inputs, output format, or whether any of the schema parameters influence the result. Some schema fields say they are 'discarded,' but the description does not integrate or explain 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 one short sentence and is front-loaded with the core concept. It wastes no words. However, it is so minimal that it omits essential invocation context, so it is concise but not fully informative.

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

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

With no annotations, no output schema, and a 9-parameter schema unrelated to timezone selection, the definition is incomplete. An agent cannot determine how to specify the IANA timezone or what the call would return. The mismatch between the description and the schema makes the tool effectively uncallable as documented.

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 input schema has detailed descriptions for each parameter, none of those parameters correspond to the timezone name the description promises. The description adds no mapping between 'named IANA timezone' and any schema field, so an agent cannot determine how to request a specific zone. This is a critical semantic gap despite the high 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 says the tool reports the current time for a named IANA timezone, which differentiates it from utc-time and iana-zones. However, no input parameter exists to specify the timezone name; the schema instead contains fields like ref, url, city, feed, host, json, and path. This makes the stated purpose hard to act on.

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 about when to use this tool versus alternatives such as utc-time or iana-zones. It does not state prerequisites, exclusions, or a preferred usage pattern. The agent is left to infer that it is for timezone lookups without any explicit routing.

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

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

No annotations are supplied, so the description carries the burden of behavioral disclosure. It does not state that the eight input parameters are ignored/discarded, that there are no side effects, or what format the returned timestamp uses. The schema's per-parameter notes cover some of this, but the description itself adds nothing behavioral.

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 three-word sentence with no filler or redundancy. It front-loads the essential output 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?

With no output schema, the description needs to specify the return format (ISO 8601 string, Unix epoch, etc.) and clarify whether any parameters are required. "Current UTC timestamp" leaves the timestamp format ambiguous, despite the input schema noting that parameters are incidental.

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 descriptions for all eight properties (e.g., "discarded after the shape check", "no disk access"), so schema coverage is high and the baseline of 3 applies. The description adds no parameter-level meaning itself, which is acceptable given the schema already documents each field.

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 as "Current UTC timestamp," which is clear about what the tool returns. However, it uses a noun phrase rather than a verb+resource construction and does not contrast itself with sibling tools like timezone.

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 only use case: obtain the current UTC timestamp. It provides no explicit when-to-use guidance or exclusions, and does not mention when timezone or other sibling tools would be more appropriate.

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

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

With no annotations attached, the description carries the full burden for behavioral disclosure. It only says 'The body is discarded,' which implies no persistence, but it does not state the return format (e.g., boolean), error behavior for invalid JSON, or whether other parameters (url, feed, path) are ever accessed. The schema's per-parameter 'discarded' notes add some transparency, but the description itself leaves major behavioral unknowns.

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, which is good for concision. However, the word 'body' diverges from the schema's parameter names, forcing the agent to infer which input is meant. It is short but not optimally precise.

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 a seven-property schema, no required list, no output schema, and an ambiguous 'body' reference, this description is incomplete. An agent cannot determine which parameters to provide, whether any are required, or what the valid JSON check returns. The mismatch between the narrow description and the broad schema makes confident invocation difficult.

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 provides detailed descriptions for all seven properties, including discard behavior, so the schema coverage is high. The description adds no parameter-specific value beyond introducing the word 'body', which is not a schema property name and actually muddies the mapping to the `json` parameter. Baseline 3 is appropriate because the schema carries the 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 states a clear action ('Check') and resource ('a body of valid JSON'), and the name validate-json reinforces the purpose. However, it never connects 'body' to the `json` parameter in the schema, and the schema exposes six other parameters (ref, url, city, feed, host, path) that are not mentioned, creating ambiguity about what exactly is validated.

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

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

No guidance is given for when to use this tool versus sibling tools like `domain-shape`, `file-path-ok`, or `fetch-status`. There are no exclusions, alternatives, or context conditions stated. The 'discarded' note hints at read-only behavior but does not help an agent decide between 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 must carry the behavioral transparency burden. It mentions the Open-Meteo source but does not disclose whether the tool makes a network call, what happens with unrelated parameters, whether the result is cached, or what error behavior occurs for an unknown city.

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. It is appropriately concise, though it sacrifices useful 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 no output schema and no annotations, the description is incomplete for safe invocation. It does not specify temperature units, return format, error handling, or which parameters are actually required or relevant, especially given the nine-parameter schema.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds that 'city' is the relevant input and that Open-Meteo is the provider, but it does not clarify that the other eight parameters are ignored, which is a meaningful ambiguity given the broad optional 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 clearly states that the tool returns the current temperature for a city and identifies the data source as Open-Meteo. It is distinct enough from sibling tools like geo-hint, though it lacks an explicit action verb such as 'get' or '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?

The usage context is implied: an agent should use this when it needs a city's current temperature. However, there is no explicit guidance on when not to use it, and the description does not address the fact that the schema contains many unrelated optional parameters.

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

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

The description discloses that only HTTP status and content type are returned and that the body is discarded, which is useful behavioral information. However, there are no annotations and no output schema, so important behavior such as redirects, timeouts, error responses, or authentication requirements is not addressed.

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 or repetition. The core result is front-loaded, and every word contributes to the meaning.

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

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

A tool with nine optional parameters, no required fields, no output schema, and no annotations needs more than an eleven-word description. The description does not connect the URL-focused behavior to the rest of the schema or help the agent choose among the many fetch-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 applies because the schema already documents each parameter. The description adds little parameter-level meaning and does not clarify why non-URL parameters like city, json, and zone appear alongside the URL-focused description.

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: retrieving HTTP status and content type for a public URL, with the body discarded. It is clear, but it does not distinguish web-fetch from closely related sibling tools such as fetch-status, 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?

No guidance is provided about when to use this tool instead of alternatives. With sibling tools like fetch-status, normalize-url, and inspect-robots available, the agent must infer selection criteria from the name and the short 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?

The only disclosed behavior is that 'Title discarded after the call.' With no annotations present, the description carries the full behavioral burden, yet it omits whether the tool is read-only, what it returns, whether it makes a network request, or how errors are reported. The discarding note is a small positive 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?

The description is extremely concise — two short sentences with no filler. The main purpose is front-loaded. It earns a high score for brevity, though it sacrifices completeness.

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

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

This tool has a seven-property schema, no annotations, no output schema, and the description is only two sentences. It fails to specify which parameter to use, what the return value is, or any side effects. The definition is inadequate for an agent to invoke it correctly.

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

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

The description never explains which input parameter corresponds to the Wikipedia title. The schema exposes seven unrelated properties (ref, url, city, feed, host, json, path), none of which is a title, creating a serious mismatch. Even though each schema property has a description, those descriptions reference 'shape check' and do not map to the described 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 states a specific action: 'Check whether a Wikipedia title exists.' It names a distinct resource (Wikipedia title) and a clear verb, so an agent can tell it apart from siblings like domain-shape or url-shape. However, it does not explicitly differentiate from related 'shape' checkers, and the word 'exists' versus 'shape' could be ambiguous.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention any conditions, exclusions, or comparison to sibling tools. An agent must infer usage entirely from the tool name and one-line description.

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