ISO country ER

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

No annotations are provided, so the description carries the full burden. It discloses that task text is discarded and lists the returned artifact types, which is useful. However, it does not address auth, side effects, rate limits, or whether any input is mutated, leaving some behavioral ambiguity.

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

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

Three short sentences front-load the action and resource, summarize outputs, and add a privacy-relevant note. There is no filler or redundant restatement 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?

With nine optional parameters, no output schema, and no annotations, this description is too thin for full invocation guidance. It does not explain which parameter should be supplied, how the returned artifacts are structured, or what happens when no gateway is found.

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. The description does not add parameter-level meaning beyond the schema; it does not explain which parameter actually selects or identifies the 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 uses a specific verb ('Find') and a named resource ('public pay-per-call tool gateway (Monid)'), then enumerates what it returns: CLI setup, how-it-works, skill file, and remote MCP hops. This clearly differentiates it from sibling utilities like web-fetch 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?

The description implies a use case: call this when you need Monid gateway setup or how-it-works details. However, it never explicitly states when not to use it or names a more appropriate sibling, so routing 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 at all, the description carries the full burden of disclosing behavior. It does usefully state 'No browser is launched,' but it omits whether a network request is made, what happens on inaccessible URLs, whether any data is returned, and whether there are side effects or rate limits. For a tool that checks URL openability, these are material 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?

The description is short, front-loaded, and contains no fluff. Both sentences earn their place, though the extreme brevity leaves important context unaddressed, preventing 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?

Given a 9-parameter schema, zero required parameters, no output schema, and no annotations, a two-sentence description is far from complete. It does not explain which parameters to provide, what the result looks like, or how the check is performed, leaving an agent without enough context to invoke it reliably.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description adds no parameter-specific insight. However, the description focuses only on 'URL' while the schema exposes 9 optional parameters including city, json, query, and path, which could confuse selection. The schema itself carries the parameter meaning, so no additional credit or penalty beyond the baseline is warranted.

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 ('Check') and resource ('a URL'), and the qualifier 'No browser is launched' helps position it against sibling tools like playwright-url-ok. However, 'can be opened' is somewhat ambiguous—it doesn't specify whether this means HTTP reachability, DNS resolution, or browser rendering—so it doesn't fully earn a 5.

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

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

There is no explicit guidance on when to use this tool versus alternatives such as playwright-url-ok, fetch-status, normalize-url, or web-fetch. The only implicit hint is 'No browser is launched,' which suggests it is not for browser-dependent checks, but no sibling is named and no selection criteria are given.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only says 'Expression discarded,' which is a useful data-retention hint, but it does not describe return values, side effects, permissions, or error behavior; the discard claim is also unmoored because no expression parameter exists in the schema.

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

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

The text is short and front-loaded, but the brevity reflects under-specification rather than useful conciseness. The second sentence, 'Expression discarded,' adds confusion because no expression parameter is defined anywhere.

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 nine-parameter tool with no annotations and no output schema, this description is not remotely complete. An agent cannot determine which parameter to populate, what the tool returns, or what conditions warrant calling it.

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

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

Schema coverage is 100%, so the schema individually documents all nine parameters, but the description adds no mapping from those parameters to the advertised arithmetic evaluation. It introduces an 'expression' concept absent from the schema and fails to indicate which parameter, if any, should carry the expression.

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 'Evaluate a+b style arithmetic,' which is close to a restatement of the tool name calc-eval and adds little specificity. It names no input parameter or output, and the schema exposes nine unrelated parameters with no arithmetic expression field, so the stated purpose does not map onto any actual argument.

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 calc-eval should be used instead of sibling tools such as validate-json or search-query-len, and no exclusions or context are provided. An agent gets no help deciding whether this tool is the right choice for a given task.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says the record is 'public' and does not explain whether the tool performs network access, what the return payload contains, or how the many optional parameters relate to the tool's 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 a single sentence with no filler and gets straight to the point. However, it may be too terse given the tool's nine optional parameters and lack of output schema, making it concise but somewhat under-specified.

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

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

With no output schema and no annotations, the description should explain what the ISO 3166-1 record contains and why the numerous parameters exist. It does neither, so an agent cannot confidently predict the tool's result or how to interact with it.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself adds no parameter information, but each parameter already has a clear description in the schema, including discard and no-disk-access behavior.

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

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

The description identifies the tool as a public ISO 3166-1 record for ER, making it clear that it concerns Eritrea country-code data. However, it is a noun phrase rather than an explicit action statement like 'returns' or 'fetches', and it does not contrast with any sibling lookup tools.

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

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

There is no guidance about when to use this tool versus alternatives, nor any mention of exclusions or prerequisites. The description only states what the record is, leaving the agent to infer when to invoke it.

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

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

With no annotations, the description carries the behavioral burden; it does add one useful guarantee ('Page content is not stored'), implying a read-only or privacy-preserving operation. But it does not disclose whether the tool makes a network request, how it handles redirects, whether it stores anything besides page content, or what happens with the other accepted inputs.

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

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

Two short sentences place the main purpose first and add only the privacy note; there is no filler, repetition, or buried detail. It is appropriately front-loaded 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?

Given several optional parameters, no required parameters, no output schema, and no annotations, the description is too thin: it does not explain the minimal invocation, the purpose of the non-URL parameters, or how the returned values are formatted. It also does not resolve overlap with nearby URL-oriented 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 schema already documents every parameter, putting this at the baseline. The description adds no new parameter semantics and does not clarify which optional parameter is the primary one for the stated purpose, beyond mentioning 'URL'.

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 the target resource ('URL') plus three concrete output fields (host, scheme, HTTP status), so an agent can clearly see what the tool produces. However, it does not contrast citation with overlapping siblings such as fetch-status or normalize-url, 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 about when to choose citation over fetch-status, web-fetch, or normalize-url, and no mention of prerequisites or exclusions. The phrase 'for a URL' only implies the general input context, not the decision between this tool and its near neighbors.

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

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

With no annotations, the description must carry behavioral disclosure, and it does offer one meaningful promise: 'No identifiers are retained.' The per-parameter schema notes about values being 'discarded' add some transparency, but the description itself does not state whether the tool makes network calls, has side effects, or how the classification is computed.

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

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

The description is only two sentences long with no filler, and the main claim is front-loaded. It is concise and easy to scan, though the brevity contributes to the lack of substantive 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?

This 9-parameter tool has no output schema, no annotations, and no explanation of what classification means, what the result looks like, or which sibling tools it complements. An agent has almost no basis for invoking it correctly or interpreting its result.

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

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

Schema description coverage is 100%, so each of the 9 parameters already has its own descriptive text. The tool description adds no extra parameter-level meaning, such as how the parameters combine or which fields are mutually exclusive, 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 says the tool will 'Show how this request is classified', which gives a general idea of classification, but never defines what classification means, what categories exist, or what output the agent should expect. The name 'compatibility' and the broad parameter list do not clarify this, and the description does not distinguish it from sibling shape-check tools like domain-shape, validate-json, or search-query-len.

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

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

There is no guidance about when to use this tool versus any of the 27 sibling tools. The description provides no context, examples, exclusions, or condition-based routing, so an agent cannot determine whether this should be called before or instead of related classifiers.

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 burden. It discloses that the operation is a split and explicitly excludes WHOIS/ownership lookup, which is useful context. However, it does not describe error behavior, return shape, or what happens when non-host parameters are supplied, leaving important behavioral 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?

The description is a single, front-loaded sentence with no filler. It is appropriately concise, but it is so terse that it omits guidance about the schema's many optional parameters.

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 nine optional parameters, the description is not complete enough. It covers only the hostname case and gives no indication of whether the other parameters are accepted, ignored, or rejected, nor what the tool returns beyond the implied label split.

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

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

Schema description coverage is 100%, so the baseline is 3 even without parameter details in the tool description. The description adds no extra parameter meaning, and its narrow focus on 'hostname' makes the presence of the other eight parameters confusing rather than clarified.

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: 'Split a hostname into labels' and adds a scope qualifier ('without WHOIS or ownership data') that helps distinguish it from ownership-lookup tools. It loses a point because the input schema exposes nine unrelated optional parameters, so an agent cannot tell from the description why url/json/city/feed/path/zone/query are accepted.

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 'without WHOIS or ownership data' implies this tool is for syntactic label extraction when ownership enrichment is not wanted, but it never names alternatives or gives an explicit when-to-use/when-not-to-use rule. Sibling shape tools exist, yet the description does not route the agent to them.

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 transparency burden. It does disclose that the tool issues a HEAD request to a public URL and returns only status, which is useful, but it does not explain behavior for the other eight parameters, the shape of the status result, error handling, or side effects. The schema's repeated 'discarded after...' notes hint at safe checks but are never clarified 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 no filler. It is easy to scan and quickly communicates the core URL 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?

A tool with nine optional parameters, no output schema, and multiple URL-related siblings needs more than a one-sentence URL description. The description is sufficient only for the URL case and leaves the rest of the schema and the meaning of 'status only' 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?

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level guidance beyond mentioning URL, and it does not explain that the nine optional parameters likely represent alternative inputs or which one an agent should populate for a given 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 names a clear action ('HEAD a public URL') and result ('return status only'), so the URL case is understandable. However, the schema exposes nine optional parameters such as city, json, path, zone, and query, whose descriptions describe status/check behavior; the description omits these, making the stated purpose narrower than the tool's actual parameter surface.

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 fetch-status versus sibling tools like browser-url-ok, playwright-url-ok, or web-fetch. The phrase 'status only' implies a lightweight check, but no explicit when/when-not conditions or alternative tool routing are provided.

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

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

With no annotations, the description carries the full burden of explaining behavior. It only says 'Parse a Figma file URL. Path discarded,' without disclosing whether the tool is read-only, what shape it validates, whether it makes network requests, or what it returns. The path-discarding note is the only behavioral detail, and it is ambiguous.

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 appropriately short and front-loaded, with the core verb/object in the first sentence and only one additional clarifying fragment. The brevity is efficient, but the 'Path discarded' fragment is cryptic and slightly reduces clarity.

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

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

For a tool with 9 optional parameters, no annotations, and no output schema, a two-sentence description is insufficient. It does not state the return value, the specific Figma URL shape being checked, or whether only the 'url' parameter is used. An agent would struggle to invoke this correctly or distinguish its output from similar URL 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 even without parameter details in the tool description. The description adds a little emphasis on 'Path discarded,' which reinforces the 'path' parameter's schema description, but it does not clarify which of the many optional parameters actually matter or how they relate to a Figma URL.

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 ('Parse') and resource ('a Figma file URL'), which clearly identifies the tool's domain and distinguishes it from sibling shape-checking tools like github-repo-shape or jira-key-shape. The phrase 'Path discarded' adds behavioral detail, though it is ambiguous about whether it means the URL path or the 'path' 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?

No explicit when-to-use or when-not-to-use guidance is given, and no alternatives are named. The intended use is implied by 'Figma file URL' and the sibling tool names, but there is no guidance on choosing this over normalize-url or browser-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?

With no annotations provided, the description carries the burden, and it does disclose an important behavioral trait: 'No disk access.' This tells an agent that invoking this tool will not read or write the filesystem, which is valuable context for a path-named tool. It does not mention return values or possible network behavior, but for a simple validator this is reasonably transparent.

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, and the key behavioral qualifier is front-loaded. It earns its place, though the word 'path' is imprecise given the broad schema, and the terseness contributes to ambiguity.

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 parameters, no annotations, no output schema, and numerous sibling tools with similar shape-check purposes. The two-sentence description is not enough to explain which parameter to provide, what 'safe' means, what the return value looks like, or how it differs from sibling tools. Significant context is missing for an agent to invoke this tool reliably.

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

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

The input schema provides descriptions for 100% of parameters, so the description does not need to restate them. However, the description offers no help selecting among the nine parameters or explaining why parameters like city, feed, ref, and query belong in a tool about 'path' safety. Schema covers semantics, but the description misses the opportunity to reconcile the parameter set with the tool's stated purpose.

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

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

The description states a clear action and object: 'Check whether a path looks safe' and adds a useful qualifier ('No disk access'). However, it does not account for the input schema's nine heterogeneous parameters (url, city, feed, json, timezone, query, etc.), making the stated purpose narrower than the actual interface and leaving ambiguity about what is really being checked.

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

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

There is no guidance about when to use this tool versus alternative shape/safety checkers among siblings such as browser-url-ok, domain-shape, wiki-title-ok, or github-repo-shape. The only usage signal is the phrase 'No disk access,' which implies a lightweight syntactic check, but no explicit conditions or exclusions are provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the external Open-Meteo dependency but does not state that this is a network query, whether inputs are discarded, whether it is read-only, or what error/rate-limit behavior might 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 a single sentence with no filler and front-loads the key idea 'latitude and longitude'. It is concise, though slightly too terse for the tool's complexity, so it does not 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?

For a 9-parameter tool with no output schema and no annotations, a one-line description leaves too much unstated: which parameter triggers the lookup, what the exact response shape is, and how this tool relates to weather-hint or other sibling tools. The core output is stated, but the definition is not complete enough 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 each of the nine parameters is already documented and the baseline is 3. The tool description adds no parameter-level guidance, and it does not clarify whether 'city', 'query', or some other field is the intended place input, which keeps this at baseline rather than higher.

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 conveys that the tool returns latitude and longitude for a place via Open-Meteo, which is a concrete outcome and distinguishes it from timezone/weather tools. It lacks an explicit verb and does not name a sibling tool, so it is clear but not maximally 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?

There is no guidance on when to use this tool versus weather-hint or other shape/hint tools. The phrase 'for a place' only weakly implies a coordinate-lookup use case, and no exclusions or alternatives are mentioned.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only says 'Parse owner and repo.' It does not explain what happens for invalid URLs, whether it also validates shape, what the return format is, or why many schema parameters (city, feed, json, path, query) appear to be unrelated. The schema descriptions actually reveal more behavioral context than 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 a single, front-loaded sentence with no filler words. It is concise and immediately readable, though its brevity comes at the cost of omitted behavioral and usage context.

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

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

For a tool with 9 parameters, no output schema, no annotations, and many sibling shape tools, a one-sentence description is not complete enough. The agent cannot determine the output shape, error behavior, or why most schema parameters exist, so the description is inadequate for reliable tool selection and 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 structured schema already documents all 9 parameters. The description adds minimal mapping value by relating the 'GitHub URL' to the url parameter, but it does not compensate for the apparent mismatch between the description and the many unrelated parameters.

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

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

The description uses a specific verb ('Parse') and identifies the exact resource ('owner and repo from a GitHub URL'). This distinguishes it from sibling tools like domain-shape or jira-key-shape by naming GitHub URLs, though it does not mention shape validation/checking implied by the tool name.

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

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

No guidance is given about when to use this tool versus alternatives such as normalize-url, browser-url-ok, or figma-url-shape. There are no usage conditions, exclusions, or references to 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 provided, the description carries the full burden. It does convey the core behavior—counting live Hacker News front-page stories—and one discard behavior ('Titles discarded'). However, it does not mention network access, rate limits, side effects, or how the many input parameters are treated.

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 and no filler. It earns conciseness points even though the second sentence is terse and leaves some gaps.

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 optional parameters, no output schema, and no annotations, this description is too sparse. It does not state whether the parameters are ignored, which one to use, or what the count result looks like. An agent can guess the basic use case but lacks enough context to confidently invoke the 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 schema already documents each parameter. The description adds almost no parameter-specific meaning beyond repeating the idea of discarding titles, which also appears in the feed parameter description. Baseline 3 is appropriate.

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

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

The description states a specific verb and resource: it counts current Hacker News front-page stories. The addition of 'Titles discarded' clarifies what is ignored, and the tool is distinguishable from generic fetch/validate siblings even without naming an alternative.

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

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

There is no guidance on when to use this tool versus siblings, and no indication of whether any of the nine optional parameters should be supplied, are ignored, or are required for certain behaviors. The context signals show required parameters are 0, but the description does not explain how to invoke it correctly.

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 merely says the tool contains timezone names but does not state what happens when it is called (e.g., returns a list, outputs to stdout), whether it is read-only, or any side effects. This is a significant gap for an agent deciding whether to invoke it.

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 phrase, which is technically concise, but it is under-specified for a tool with 9 parameters and no output schema. It lacks structure or elaboration that would justify its brevity; it is more under-developed than appropriately compact.

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

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

Given the complexity (9 parameters, no output schema, no annotations), the one-sentence description is insufficient. It does not explain what the tool returns, how the parameters are used, or how this fits into the workflow of 'clock calls'. An agent would be uncertain about the tool's behavior and interaction with its parameters.

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

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

Schema description coverage is 100%, and each parameter (e.g., 'url', 'city', 'json') has its own description. The tool-level description adds no additional meaning about how these parameters relate to the timezone name lookup, but the schema already documents the parameters individually, so the baseline of 3 holds.

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 resource ('Common IANA timezone names') and its intended use ('for clock calls'), making it reasonably clear what the tool provides. However, it doesn't differentiate from sibling tools like 'timezone' or 'utc-time', which could also be related to timezone handling.

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' provides only a vague context of use, with no explicit guidance on when to choose this tool over alternatives such as 'timezone' or 'utc-time'. There are no exclusions or conditions stated, leaving the agent to infer the usage scenario.

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 disclosure burden. It does disclose that the tool performs a network fetch of a public resource and returns only counts rather than full content. However, it does not explain what 'group counts' means, how missing or malformed robots.txt responses are handled, or that several schema parameters appear to be discarded.

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

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

The description is one short sentence with no filler, and the main action is front-loaded. It loses a point because the extreme brevity omits needed routing information, 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?

For a tool with 9 optional parameters, no output schema, and no annotations, this definition is incomplete. It does not say which parameter supplies the target URL, what the returned counts look like, or how this tool differs from the large sibling set of fetch and shape 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 description coverage is 100%, the tool description adds no parameter mapping: it never identifies which of ref, url, city, feed, host, json, or path should receive the robots.txt URL. The schema descriptions themselves are generic and unrelated to robots.txt (e.g., 'normalize or cite', 'weather hint', 'validate'), leaving the agent unable to invoke the tool confidently.

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 ('Fetch'), a concrete resource ('a public robots.txt'), and an output constraint ('return group counts only'). This distinguishes it from most siblings, which deal with URLs, keys, or fetch status. However, it leaves 'group counts' undefined and does not map the purpose to any of the 9 schema parameters.

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 the many related siblings such as web-fetch, fetch-status, normalize-url, or domain-shape. The only usage signal is implied by the action itself, with no exclusions, alternatives, or preconditions 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 present, so the description carries the behavioral burden. 'Key discarded' usefully signals a non-persistent, side-effect-free check and aligns with the schema's 'discarded' notes. But it does not describe the output, error behavior, or any external dependencies.

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

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

The description is extremely concise and front-loaded with the main purpose, and each sentence adds information. The brevity costs clarity because the critical parameter mapping is omitted, preventing 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?

Given seven parameters, no annotations, and no output schema, the description omits essential invocation context: which input to provide, expected key shape rules, return value, and invalid-input behavior. Only the non-persistence hint is present, leaving the agent to guess.

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 itself documents all seven string parameters, so the baseline would normally be 3. However, the description refers to a 'Key' that maps to no property in the schema, leaving the agent unable to determine where to supply the Jira key. This mismatch undermines parameter selection despite strong schema-level descriptions.

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

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

The description states a specific action ('Check') and a specific resource ('Jira issue key shape'), which conceptually distinguishes it from sibling shape-checking tools like github-repo-shape or domain-shape. However, it never identifies which input schema property carries the key, so the purpose is clear only at a high level.

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

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

There is no guidance on when to use this tool versus alternatives; it does not mention sibling tools, prerequisites, or exclusions. The only usage clue is implicit in the name and the phrase 'Check a Jira issue key shape.'

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?

'Body discarded' is a meaningful behavioral disclosure and tells the agent that only the status is returned. However, with no annotations, the description does not cover error/redirect handling, whether a network request is actually made, or any side-effect/prerequisite profile.

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: purpose is front-loaded and the second sentence adds a useful behavioral constraint. 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 9 optional parameters, no annotations, no output schema, and a large sibling set, this description is too thin. It does not identify which parameter to populate or how to route among similar URL/status siblings, so an agent cannot call it with full confidence.

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 a public-library-docs context, but it never names the `url` parameter, and the schema's `url` description ('normalize or cite') does not align cleanly with the status-checking 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 identifies a specific resource (public library docs URL) and an output (HTTP status), and 'Body discarded' distinguishes it from body-returning fetches. It lacks an explicit verb and does not map the purpose to a schema parameter, but the core action is clear.

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

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

There is no guidance about when to use this tool instead of the many sibling URL/status tools such as fetch-status, web-fetch, browser-url-ok, or normalize-url. The intended context is only implicit in the name and noun-phrase 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 the full burden of disclosing behavior. It states that values are discarded, which is useful, but it does not say what the tool returns, whether it counts top-level keys only or nested keys, or what happens for invalid JSON. This is insufficiently transparent for a tool with no output schema.

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: the core operation is in the first sentence and the key constraint in the second. Every word earns its place, though the brevity comes at the cost of important missing detail.

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

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

For a tool with seven optional parameters, no required fields, no output schema, and many siblings, the description is not complete enough for reliable invocation. It should specify the target parameter, the return value, and how nested keys are counted.

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 identify which parameter supplies the JSON object among seven optional parameters. The schema's 'json' field is described as text to validate, not text to count, and no other parameter connects to counting keys. The description adds no disambiguation for parameter selection.

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 ('Count keys') and a resource ('a JSON object'), and the phrase 'Values discarded' clarifies that the count is key-only. It is not a tautology and is broadly distinguishable from siblings like validate-json, but it does not explicitly differentiate itself or mention the relevant 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?

There is no guidance about when to use this tool versus validate-json, hn-front-count, or other sibling tools. The intended use is only weakly implied by the description, with no mention of alternatives, 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, the description carries the behavioral burden. It clearly states that query and fragment are dropped, which is useful, but it does not disclose error handling, invalid URL behavior, or the fact that the schema contains many apparently unrelated parameters that are discarded. The description is honest 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 core output is stated first, and the dropping behavior is added immediately after. 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?

Despite the simple core behavior, the tool has nine parameters, no required parameters, no output schema, and no annotations. The description does not specify what the returned origin/host/path structure looks like, nor does it clarify how to choose among the many parameters. This is insufficient for reliable invocation in a complex schema context.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds the useful clarification that query and fragment are dropped from the URL, but it does not explain which of the nine parameters are relevant or how they relate to the normalization operation.

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') with a clear resource ('origin, host, and path for a URL') and a concrete behavior ('Query and fragment are dropped'). This makes the tool's purpose recognizable, though it does not explicitly distinguish itself from sibling URL-related tools like 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?

The intended use is implied: use this tool when you need origin, host, and path from a URL while discarding query and fragment. However, there is no explicit when-to-use or when-not-to-use guidance, and no alternatives are named among the 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 responsibility for behavioral disclosure. It does disclose one meaningful behavior: no browser is launched. However, it does not say whether the tool makes a network request, performs only a local shape check, has side effects, or what the return value represents, leaving important behavioral gaps for an agent.

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

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

Two short sentences with no filler. The main purpose and the critical no-browser behavior are front-loaded. Every word earns its place.

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

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

The tool accepts nine optional parameters and has no output schema, yet the description does not explain what result an agent should expect, how URL checking works, or which parameters are relevant to which scenario. The description is too minimal for the tool's actual complexity and leaves critical invocation details unspecified.

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, including notes about values being discarded and what each field is for. The description itself adds no parameter-level semantics beyond the schema, so the baseline 3 is appropriate.

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

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

The description states a specific verb and resource: 'Check whether a URL can be opened.' It also adds the key differentiator 'No browser is launched,' which helps distinguish it from browser-url-ok. However, 'can be opened' is ambiguous: it could mean syntactic shape validation, network reachability, or HTTP status checking, so it does not fully clarify the exact nature of the check.

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' note implies this is a lightweight alternative to browser-based checks, but the description never explicitly says when to use this tool versus browser-url-ok, fetch-status, domain-shape, or normalize-url. 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. It does disclose that the query is discarded, which is a useful non-retention trait. However, it does not explain the behavior for the other eight accepted parameters or what the tool returns, leaving a significant transparency 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?

Two short sentences with no filler. The core action is front-loaded, and the discard behavior is stated in a single additional sentence. 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?

With no output schema, nine parameters, and no annotations, the description is too sparse to be contextually complete. It does not explain the return value, the role of the unrelated-looking parameters, or why all those parameters are accepted. An agent would need to infer important details from the schema alone.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds no parameter-level meaning beyond suggesting that 'query' is the relevant search text, which the schema already states.

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 characters in a search query.' This is clear and distinguishes the tool from siblings like memory-key-count or hn-front-count, though it does not explicitly explain how the returned count is presented.

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 exclusions, and no mention of expected input context. The description only says what it 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?

No annotations are provided, so the description must carry the full behavioral burden. It only says the catalog is 'short' and gives no detail about return shape, side effects, whether any parameters are actually used, or whether this is a pure read-only operation. The schema hints that values are discarded, but the description itself is silent.

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

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

The description is one short sentence with no filler, which is efficient. It is slightly under-specified, but as a structure and conciseness matter it earns a strong 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?

With no output schema and seven loosely related optional parameters, the description is too thin to make the tool safely callable. An agent would not know what the catalog returns, how parameters affect the result, or why tools like weather-hint or validate-json appear to overlap with this tool's input 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 descriptions exist for all seven parameters, so the parameter baseline is covered. However, the tool description adds no meaning beyond the schema and does not explain how these unrelated parameters relate to HTTP status codes or the catalog output.

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

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

The description identifies the resource as a short catalog of common HTTP status codes, which gives a basic idea of the tool's purpose. However, it is a noun phrase with no explicit verb like returns or lists, and it does not distinguish the tool from siblings such as fetch-status. The unrelated input parameters also cast doubt on what the tool actually does with them.

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

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

There is no guidance on when to use this tool instead of alternatives like fetch-status, compatibility, or validate-json. The description implies it is a reference lookup, but it never states the intended context, exclusions, or conditions.

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

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

With no annotations, the description bears the behavioral burden. 'Prompt discarded' is genuinely useful because it tells the agent the input is thrown away and the tool is effectively a fixed template generator. However, it does not disclose what the template contains, whether all nine optional parameters are ignored, or any error/edge behavior.

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

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

Two short sentences, core behavior first, caveat second. Every word contributes and nothing is redundant.

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 fixed-output tool this is almost enough, but there is no output schema and no annotations. The description leaves ambiguity about whether any of the nine optional parameters are actually consumed, and it does not describe the shape of the returned three-step template.

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

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

Schema description coverage is 100%, so the schema already explains every parameter. The description adds no per-parameter meaning, apart from loosely implying the prompt is not used. That falls at the baseline of 3 for high schema coverage.

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

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

The description has a specific verb and object: it returns a three-step thinking template. Adding 'Prompt discarded.' clarifies that the tool does not consume or analyze the prompt, which distinguishes it from sibling tools that inspect, validate, normalize, 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?

There is no explicit guidance about when to use this tool versus alternatives. It does not name any sibling tool, give a condition for choosing it, or state a when-not-to-use scenario. 'Prompt discarded' only says the prompt is irrelevant; it does not explain when an agent should call 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?

No annotations are present, so the description carries the full burden. 'Current time' clearly implies a read-only lookup and 'named IANA timezone' constrains the input. It does not disclose output format or error behavior, but those omissions are not severe for such a simple lookup.

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 phrase with no filler. Every word contributes to specifying scope and the key fact is front-loaded.

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

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

The tool is simple and the schema supplies the parameter details, but with no output schema and a nine-parameter optional input schema, the description could have more explicitly pointed to the `zone` parameter or noted the return format. It is adequate for selecting the tool but not fully complete.

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

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

The schema already documents all nine parameters with 100% coverage, including `zone` as 'IANA timezone name'. The description only reinforces the IANA-name requirement and adds no additional parameter-level meaning, so it stays at the 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 conveys that the tool returns the current time for a named IANA timezone, and the 'named IANA timezone' phrasing distinguishes it from siblings like utc-time and iana-zones. It lacks an explicit verb such as 'returns' or 'gets', which keeps it 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?

When to use the tool is implied: an agent needing current time for a specific IANA timezone can infer this is the right choice. However, there is no explicit comparison to utc-time or iana-zones and no statements about 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?

With no annotations present, the description carries the full burden of disclosing behavior. It states only the returned value and does not say whether the seven optional input properties are ignored, what timestamp format is produced, or whether any side effect or network access occurs.

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?

It is extremely short and free of filler, but the terseness crosses into under-specification. A single fragment does not constitute a structured explanation of the tool's behavior.

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

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

The tool has a confusing schema with unrelated optional parameters and no output schema or annotations, yet the description does not explain how those parameters relate to the UTC timestamp result. An agent cannot be fully confident whether to pass arguments or what exact output to expect.

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

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

The description adds nothing about the seven parameters, but the input schema already names and describes each one, giving high schema coverage. Per the baseline rule, the description is not penalized heavily, yet it also fails to add any unifying context such as 'all parameters are optional and ignored.'

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

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

The phrase 'Current UTC timestamp' clearly identifies the tool as returning the current UTC time, and the 'UTC' qualifier distinguishes it from generic timezone tools. It lacks an explicit verb and does not call out sibling alternatives, so it stops 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?

There is no guidance about when to use this tool instead of timezone, iana-zones, or any other sibling. No exclusions, prerequisites, or alternative conditions are stated, leaving the agent to infer the only sensible use case.

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

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

Annotations already mark the tool as idempotent and read-only, so the safety bar is covered. The description adds the explicit behavior that the input body is discarded after validation, which is useful, non-obvious context about data handling. There is no contradiction with the annotations.

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 core action front-loaded and the disposal behavior in the second sentence. No filler, redundancy, or unnecessary detail.

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

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

For a simple validation tool, the core purpose and side effect are given, but the description never maps 'body' to a specific input parameter and does not state the result shape for valid versus invalid JSON. Given the broad input schema and no output schema, this is minimally viable but not complete.

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 each property with descriptions, including 'json': 'JSON text to validate; discarded after the check', so schema coverage is high. The description's generic 'body' adds no parameter-level meaning beyond what the schema provides, matching the 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 names a specific operation ('check') and resource ('valid JSON body'), making the tool's function immediately clear. It is easily distinguished from sibling shape validators such as domain-shape or jira-key-shape, which cover other formats.

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 of checking JSON validity is implied by the purpose statement and the discard note, but the description does not state when-not-to-use it or name any alternative tools. It gives clear context for one straightforward scenario, but no 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It names the external source but does not reveal that the other eight schema parameters appear to be ignored/discarded, nor does it describe output, error behavior, or side effects.

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

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

The description is a single concise sentence with no filler. The core purpose and external data source are front-loaded, making it easy for an agent to parse quickly.

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

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

The tool has 9 parameters, no required fields, no output schema, and no annotations, so the description needs to compensate. It does not state what the return value looks like, which parameter to fill, or that the other parameters are discarded, leaving an agent uncertain how to invoke it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3 even without parameter information in the tool description. The description does point to 'city' as the relevant parameter, but it does not clarify that the many other parameters are irrelevant to this tool.

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

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

The description states the tool's function with a specific resource ('current temperature for a city') and source ('Open-Meteo'). It is distinguishable from sibling tools, though it lacks an explicit verb like 'gets' or 'returns'.

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

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

The context 'Current temperature for a city' implies the intended use case, and the name weather-hint helps identify it. However, it gives no when-to-use guidance or alternatives, and the schema's 0 required parameters leave selection ambiguous.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It does disclose the key outcome and the fact that the body is discarded. However, it does not mention redirects, timeouts, response shape, or how the many unrelated input parameters are treated, so the disclosure is only partially complete.

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

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

Two short sentences, front-loaded with the result and ending with the most important behavioral caveat. Every word earns its place; there is no redundant or filler content.

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

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

Despite a 9-parameter schema, no annotations, and no output schema, the description covers only the URL-focused behavior. It gives no guidance about the purpose of the extra inputs like city, feed, json, or path, so an agent cannot tell whether they are ignored, validated, or used as alternate fetch targets.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds only the 'public URL' gloss and does not clarify how the nine optional parameters relate to fetching. The schema's url description ('normalize or cite') also conflicts slightly with the tool description's fetch behavior, leaving some ambiguity.

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: return 'HTTP status and content type' for a 'public URL', with the key limitation 'Body discarded.' This is clear and useful, but it does not explicitly differentiate from sibling tools like fetch-status or normalize-url, so it stops short of full sibling 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?

The description implies when to use the tool: when all you need is HTTP status and content type for a public URL and the body is not needed. It provides an implicit exclusion via 'Body discarded,' but it never names alternatives or explains when to prefer web-fetch over fetch-status, browser-url-ok, or normalize-url.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, idempotentHint=true, and safe=true, so the description does not need to repeat the safety profile. It adds one behavioral detail, 'Title discarded after the call', which addresses data retention. It does not describe the existence-check mechanism or output format, but for a read-only checker this is adequate.

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 the core action front-loaded and no fluff. However, the second sentence is confusing because there is no title parameter in the schema, and the brevity leaves critical invocation details unstated, making it under-specified rather than cleanly 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?

With no output schema and seven schema properties, the description should clarify which parameter represents the title and what the return contract is. It provides neither, and the mismatch between the stated purpose and the parameter list makes the tool effectively non-invocable without further investigation, despite the safety annotations covering side effects.

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

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

The schema has seven parameters, all with individual descriptions, so schema description coverage is high. Yet the description's key noun 'title' does not appear in the schema, and no property is identified as the Wikipedia title; ref, url, city, feed, host, json, and path are described as unrelated values. The description fails to help an agent select the correct argument, which is the core invocation problem.

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') and a clear resource, making the tool's purpose identifiable and distinct from most shape-checker siblings. However, it never connects the stated purpose to any input parameter, so the purpose is not fully actionable from the description alone.

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 or when-not-to-use guidance, and no mention of alternatives such as domain-shape, browser-url-ok, or normalize-url. The only implication is that this tool performs a validation check, but no routing criteria or exclusions are provided.

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