ISO country GU

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

There are no annotations, so the description carries the behavioral disclosure burden. It does disclose that task text is discarded and describes the return values, and 'Find' implies a read-only operation. Still, it does not explicitly state there are no side effects, whether remote MCP hops are executed or merely described, or any rate/auth limits.

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

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

The description is two short sentences with no filler. The main purpose is front-loaded, the return list is compact, and the 'Task text discarded' note is relevant and economically stated.

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

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

With nine optional parameters, no output schema, and no annotations, the description is too thin to support correct invocation. It does not explain what inputs should be supplied, whether parameters are mutually exclusive, or how the outputs are structured.

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 every parameter is already documented at the schema level. The tool description adds little parameter-level meaning: it does not explain how the nine optional parameters influence the results or map to the returned outputs.

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 resource ('Monid'), a clear action ('Find'), and lists the returned artifact types (CLI setup, how-it-works, skill file, remote MCP hops). It does not explicitly contrast with siblings, but 'Monid' is distinctive enough to differentiate it from the surrounding generic tools.

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

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

The description implies the use case: use this tool when you want Monid's gateway setup and related files. However, it gives no explicit when-not-to-use guidance, no prerequisites, and no mention of alternatives such as web-fetch or normalize-url that could overlap.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states that no browser is launched, but does not explain whether it makes a network request, what success means, whether there are side effects, or how the result is returned. This is minimal transparency for a tool with nine 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 two short sentences with no filler. The core action is front-loaded, and the behavior differentiator 'No browser is launched' is a valuable, relevant addition.

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

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

This tool has nine optional parameters, no output schema, and no annotations, yet the description only provides a one-line purpose and a single behavioral note. It is not complete enough for an agent to confidently invoke it correctly, especially given the ambiguous 'can be opened' and the unused 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%, so the schema already documents every parameter. The description adds no parameter-level meaning beyond mentioning URL, and it does not compensate for the large number of discarded parameters. 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?

States the specific action 'Check whether a URL can be opened' with the resource being the URL. The phrase 'No browser is launched' helps differentiate it from sibling tools like playwright-url-ok, though 'can be opened' is somewhat ambiguous about whether this is a syntax check, a network check, or both.

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 lightweight usage by saying 'No browser is launched,' which hints it is preferable when avoiding a browser launch. However, it gives no explicit guidance about when to choose this tool over alternatives or when not to use it, such as when actual browser rendering is required.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that the expression is 'discarded', suggesting no persistence, but does not clarify the return value, side effects, or whether the result of evaluation is returned. 'Evaluate' implies an outcome, yet the description leaves that outcome unspecified.

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

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

The description is very short and the core action is front-loaded, which is good. However, the second sentence 'Expression discarded' is cryptic and does not clearly earn its place because it obscures the tool's behavior rather than clarifying it.

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 no annotations, no output schema, nine parameters, and many sibling tools, this description is incomplete. It fails to explain what is returned, which parameter to pass, or how this tool differs from similar checkers. An agent would struggle to call it correctly based on this definition 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?

Although the schema has 100% description coverage for its parameters, none of those parameters appears to represent the arithmetic expression the tool is supposed to evaluate. The description mentions 'a+b style arithmetic' but fails to map that concept to any of the nine input fields, leaving the agent without a clear way to invoke the tool.

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

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

The description states a clear action ('Evaluate') on a specific resource ('a+b style arithmetic'), which distinguishes it from sibling shape-check and fetch tools. However, the phrase 'Expression discarded' introduces ambiguity about whether a result is returned, and no parameter is named as the expression.

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

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

No guidance is provided about when to use this tool versus alternatives, and no sibling tools or exclusions are mentioned. The unique arithmetic purpose implies usage context, but the description does not explicitly state when an agent should invoke calc-eval.

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

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

With no annotations provided, the description carries the disclosure burden. 'Page content is not stored' is a substantive side-effect disclosure, and the stated output scope clarifies it does not return page content. It omits details such as redirect/error behavior, but the most important behavioral trait is covered.

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 primary purpose and followed by one key behavioral caveat. 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 multiple optional parameters and no output schema, the description is incomplete: it does not specify the return format, the role of the non-URL parameters, or what a caller should expect on failed URL checks. The schema fills many gaps, but the description alone is only minimally adequate.

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

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

Schema description coverage is 100%, so the parameters are already documented individually. The tool description adds only the general 'for a URL' pointer, which helps select the url parameter but does not explain how the other optional parameters relate or do not relate to the output. This meets the baseline but adds little over 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 action and output: 'Return host, scheme, and HTTP status for a URL.' It also adds a distinguishing constraint ('Page content is not stored'), which separates it from content-fetching siblings. It does not explicitly compare itself with fetch-status, so it is clear but not perfectly differentiated.

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

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

The use case is implied by the output description: use it when only host/scheme/HTTP status are needed and page content is not wanted. However, it never names an alternative or gives an explicit when-not-to-use, so an agent must infer the boundary versus siblings like web-fetch or fetch-status.

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

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

With no annotations, the description itself must disclose behavior, and it does contribute one meaningful guarantee: 'No identifiers are retained.' However, it does not state side effects, output shape, external dependencies, or whether the classification is deterministic, leaving much of the behavioral burden uncovered.

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, zero filler, purpose front-loaded, and the privacy statement earns its place. The description is as compact as possible while adding one distinct behavioral fact.

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 and no output schema, the description leaves the main output contract unspecified: what classification categories are produced, what the response looks like, and how the nine optional inputs relate to the classification. The privacy note and schema parameter descriptions are helpful, but the core operation remains opaque.

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

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

Schema coverage is 100%, with every one of the nine optional parameters already carrying its own purpose and disposal note in the input schema. The tool description adds no parameter-level meaning, so the baseline of 3 applies; the schema does the heavy lifting.

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 concrete verb ('Show') and names the object ('this request'), but the classification scheme is left undefined: an agent cannot tell what classes are returned or what 'classified' means here. It is not a tautology, but it also does not distinguish the tool from its many sibling introspection/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?

The description offers no explicit when-to-use or when-not-to-use guidance, and does not name any alternative tool. The only implied cue is that the tool acts on 'this request', which weakly suggests a current-context introspection use, but this is not enough to route reliably among the many sibling tools.

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

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

With no annotations, the description carries the transparency burden. It usefully discloses that no WHOIS/ownership enrichment happens, but it does not explicitly state that the operation is local/read-only, how invalid hostnames are handled, or what other inputs (if any) are 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?

A single front-loaded sentence with no filler: the core action appears first and the qualifier is a short clause. 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 description plus schema is minimally adequate for a simple utility: an agent can infer the input (`host`) and the return concept (labels). But there is no output schema and no annotation, and the description does not state the exact return shape or clarify why so many unrelated optional parameters exist.

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

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

Schema description coverage is 100%, so the baseline is 3; the description adds no parameter-level detail beyond mapping 'hostname' to the host field. The broad optional schema creates some ambiguity about which of the nine parameters to provide, but the schema's own descriptions ('Public hostname', 'discarded...') mostly compensate.

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

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

The description names a specific verb/resource pair ('Split a hostname into labels') and adds a clear boundary ('without WHOIS or ownership data') that distinguishes it from domain-enrichment tools. Among the shape-check siblings, 'domain-shape' is immediately identifiable as the hostname-label utility.

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 a hostname needs to be decomposed into labels, and the WHOIS caveat signals it is not for ownership lookups. However, it does not name any alternative tool or state explicit when-not conditions, leaving the routing mostly to inference.

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

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

With no annotations, the description carries the full burden, and it states the method, scope, and output kind. But it does not disclose redirect handling, error/status encoding, whether non-public URLs are rejected, or what happens when the other eight schema parameters are supplied, which is especially important given the mismatch between the URL-only description and the broad 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?

A single front-loaded sentence with no filler; the action, target, and output restriction are stated in nine words. This is appropriately concise for the core action, even though other dimensions need more 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 9 optional parameters, no output schema, and no annotations, the one-sentence description is not complete enough. It lacks a return-value contract, behavior when no URL is supplied, and clarification of how the non-URL parameters relate, so an agent cannot reliably predict the tool's response or edge cases.

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

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

Schema coverage is 100%, so the schema already documents all nine parameters; the description only adds that the URL should be public and HEADed. It does not clarify which parameter is the primary input or whether the other optional fields are ignored, so it stays at the baseline rather than adding significant semantic value.

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

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

The description names a specific action (HEAD request), a resource (public URL), and an explicit result (status only), which is clear and distinct from content-fetching siblings like web-fetch. However, the 9-parameter schema includes many non-URL fields, so the scope is not fully reconciled and the agent may be unsure whether only the url parameter is relevant.

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

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

The phrase return status only implies this tool is for lightweight HTTP status checks rather than fetching content or doing a full browser check. There is no explicit when-to-use/when-not-to-use guidance or mention of alternatives such as web-fetch or browser-url-ok, so the routing is only implied.

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

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

With no annotations, the description carries the full behavioral burden, but it only discloses that the path is discarded. It does not state whether the tool makes network requests, what output it returns, how invalid URLs are handled, or whether it is read-only. This is insufficient for a no-annotation tool.

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

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

The description is very short and front-loads the core action in the first sentence. 'Path discarded' adds a behavioral note without wasting words. However, the terseness borders on under-specification rather than efficient 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?

Given no output schema, no annotations, and 9 optional parameters, the description is too sparse for reliable invocation. It does not say which parameter receives the Figma URL, what a successful parse returns, or what happens with non-Figma URLs. The presence of many sibling tools amplifies the need for clearer routing.

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 Figma-specific context and hints that `path` is ignored, but it does not explicitly map the Figma URL to the `url` parameter nor explain the relevance of the other eight optional parameters. The added semantic value is marginal.

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

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

The description states a specific verb ('Parse') and resource ('a Figma file URL'), which clearly distinguishes it from sibling URL/shape tools like domain-shape or normalize-url. The appended 'Path discarded' is ambiguous (URL path vs the `path` parameter), which slightly weakens the clarity of what the parse yields.

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

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

No guidance is provided on when to use this tool versus alternatives such as normalize-url or browser-url-ok. There are no conditions, exclusions, or context cues to help an agent choose between the many sibling shape tools.

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

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

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It does disclose 'No disk access,' which is useful, but it does not specify what 'looks safe' means, whether the check is purely syntactic, whether it returns a boolean, or what happens with invalid or missing inputs. An agent cannot predict the tool's behavior reliably.

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

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

The description is short and front-loaded: the core purpose appears first, and the important 'No disk access' caveat follows immediately. There is no filler. It is concise, though perhaps too terse given the complexity of the schema and the lack of other 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?

This tool has nine optional parameters, no output schema, no annotations, and multiple likely sibling tools with overlapping concerns. The description only covers the path-checking aspect and gives no information about return values, expected input selection, or how to handle the other listed parameters. It is not complete enough for an agent to invoke the tool correctly with 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 each parameter is individually documented. The description adds no extra parameter meaning beyond confirming the path focus. Given the high schema coverage, the baseline of 3 is appropriate; the description does not need to repeat parameter details, though it also does not clarify which of the nine schema properties are actually relevant 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 clearly states a specific verb and resource: 'Check whether a path looks safe.' This is more informative than a tautology and aligns with the tool name. However, the input schema exposes nine unrelated parameters (url, city, json, zone, etc.), and the description does not explain how those relate to the path-checking purpose, which creates some ambiguity about the tool's actual scope.

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. Sibling tools like browser-url-ok, normalize-url, or validate-json likely cover some of the other parameters in the schema, but the description provides no routing or exclusion criteria. 'No disk access' hints at a safe validation use case but does not explicitly state when to prefer 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?

With no annotations, the description has to disclose behavior itself. It reveals an external dependency on Open-Meteo and implies a read-only lookup, but it does not explain return format, network/error behavior, or why most of the nine schema parameters are marked 'discarded after...'.

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

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

A single sentence with no filler, and the core output is front-loaded. It is concise, though terse to the point of under-specification, which is penalized in other dimensions.

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

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

For a tool with 0 required parameters, 9 optional parameters, no output schema, and no annotations, the description leaves essential invocation details missing: which parameter to set, what the returned coordinates look like, and what all the discarded-field semantics mean. It cannot fully support correct tool selection or invocation.

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

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

All nine parameters already have schema descriptions, so the tool description only needs to add mapping value. It adds the loose notion of 'a place' but does not identify which parameter supplies it, so it neither raises nor lowers the high-coverage 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 concrete output (latitude and longitude) and a data source (Open-Meteo), so it is not a tautology and is roughly distinguishable from weather/timezone siblings. However, it lacks an explicit verb like 'geocode' or 'resolve' and never states what input represents the place, which leaves the purpose somewhat 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 choose geo-hint over weather-hint, timezone, or iana-zones, nor any exclusions or conditions. The phrase 'for a place' is the only implicit usage signal, which is insufficient in a sibling-heavy tool set.

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

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

With no annotations, the description carries the full behavioral burden, yet it only states a parse action. It does not disclose error behavior, return format, whether input is normalized or discarded, or any side effects; the schema's 'discarded' notes are not reflected 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 words. It states the core operation clearly in the fewest words possible.

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 required parameters, no output schema, and no annotations, the description is too thin. It never explains which parameter(s) to populate, what a successful parse returns, or how invalid/non-GitHub URLs are handled.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds GitHub-specific meaning to the url parameter, but the other parameters (city, feed, json, etc.) are unrelated to GitHub URLs and the description gives no guidance on which are relevant or how they interact with parsing.

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 action ('Parse') with a clear resource ('owner and repo') and a concrete input source ('a GitHub URL'). This is enough to distinguish the tool from sibling shape tools for Figma, Jira, or domain names and from generic URL tools like normalize-url.

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

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

The GitHub URL mention implies the tool should be used when an agent needs owner/repo from a GitHub URL, but there is no explicit when-to-use/when-not-to-use guidance and no alternative tool is named. It does not explain what to do for non-GitHub URLs.

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

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

The description adds one behavioral detail beyond the tool name: 'Titles discarded' signals that the tool returns a count and does not include titles. However, with no annotations, the description carries more burden and still omits output format, live-fetch behavior, and handling of unavailable HN data.

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. Every word earns its place, and 'Titles discarded' is a terse but meaningful qualifier.

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 purpose, the tool has 9 optional parameters, no output schema, and no annotations. The description does not explain that parameters are unnecessary, what the exact return value looks like, or why the schema contains unrelated fields. Agents are left with too much ambiguity for a correct call.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning, and the schema descriptions are unusual—many say values are 'discarded'—but the description itself neither clarifies nor actively contradicts 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 clearly states a specific action and resource: 'Count current Hacker News front-page stories.' The added phrase 'Titles discarded' further clarifies that the result is likely a count rather than story titles. It does not explicitly differentiate from siblings, but no sibling targets HN front-page counting.

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, or when not to use it. The description does not mention that no parameters are required or that the supplied parameters are largely ignored/discarded, leaving the agent to infer call 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?

With no annotations, the description carries full responsibility for disclosing behavior. It implies a read-only reference operation but never states the return format, whether any parameters are ignored, or that no arguments are needed. The minimal wording gives an agent little insight into actual call 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 extremely concise, front-loading the core resource with no filler or redundant phrasing. It is more of a noun phrase than a full sentence, but every word contributes to identifying the tool's purpose.

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

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

The tool has no output schema and no annotations, yet accepts 9 optional parameters that are not obviously connected to IANA timezone names. The description does not clarify the return shape, whether arguments are expected, or how the tool relates to timezone and utc-time. An agent would likely need to inspect the schema and make assumptions.

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

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

All 9 parameters have descriptions in the schema (100% coverage), so the description does not need to restate them. The schema already documents each field, including discard behavior for several inputs. The tool description adds no parameter-level meaning, but the baseline of 3 applies because schema coverage is high.

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 the intended context ('for clock calls'), so an agent can infer the tool provides a list of timezone names. It lacks an explicit verb and does not explicitly differentiate from sibling tools like timezone or utc-time, but it is still sufficiently clear.

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

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

The phrase 'for clock calls' gives a clear usage context: this tool is relevant when clock-related operations need IANA timezone names. However, it does not explicitly state when not to use it or mention alternatives such as timezone or utc-time, leaving usage guidance mostly implied.

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

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

With no annotations, the description carries the behavioral burden. It does disclose the network fetch and that only group counts are returned, but it omits edge behaviors such as missing robots.txt, invalid URLs, redirects, or rate limits. 'Public' and 'only' add useful transparency, yet the coverage is minimal.

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

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

A single, front-loaded sentence with no filler. Every word ('Fetch', 'public', 'group counts only') contributes to the tool's purpose and scope.

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

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

The tool has no annotations, no output schema, and nine optional parameters, yet the description leaves critical invocation details unspecified: which parameter holds the robots.txt URL, what 'group counts' means structurally, and how failures are reported. This is insufficient context for reliable selection and correct invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself adds no parameter-level meaning and does not say which of the nine optional parameters (e.g., url vs host) provides the robots.txt target, but the schema already documents each parameter's own semantics.

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

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

The description states a specific action ('Fetch a public robots.txt') and a specific output constraint ('return group counts only'). This differentiates it from raw-fetch siblings like web-fetch or fetch-status by making clear it is a summarizing inspection, not a full-content retrieval.

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 public robots.txt count summaries, but it gives no explicit when-to-use or when-not-to-use guidance and names no alternative tools. An agent can infer the intent from 'robots.txt' and 'group counts only,' but the description leaves the choice vs web-fetch/fetch-status to inference.

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

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

Annotations are absent, so the description carries the full behavioral burden. It does disclose that the key is discarded, which is a useful privacy signal, but it does not say whether the operation is local/read-only, performs any network call, requires permissions, or how the 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 sentences with no filler and front-loads the core purpose. It is appropriately terse for a simple validator, though 'Key discarded' introduces ambiguity rather than resolving it.

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, the definition is far from complete. It omits the expected key format, the parameter to use, and the return contract, making successful invocation effectively impossible without additional context.

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

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

Although schema coverage is 100%, none of the nine parameters is described as the Jira issue key. The schema includes ref, url, city, feed, host, json, path, zone, and query, with no obvious mapping to the described purpose. The description says 'Key discarded', but no parameter represents the key, so an agent cannot determine which field to populate.

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

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

The description states a specific action and resource: check the shape of a Jira issue key. This distinguishes it from sibling tools like github-repo-shape or domain-shape, but it never explains what a valid Jira key shape is or what the tool returns.

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

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

No guidance is given about when to use this tool instead of the many sibling validators such as github-repo-shape, wiki-title-ok, or search-query-len. The agent is left to infer usage from the name and terse 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?

The description discloses a meaningful behavioral trait: the body of the response is discarded, so only the HTTP status is returned. However, with no annotations provided, it does not cover redirects, error behavior, timeouts, or the side effect of making an external network request.

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 'Body discarded' is a concise, valuable behavioral 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?

Despite 100% schema coverage, the tool has nine optional parameters and many sibling tools, yet the description does not explain how to select the correct parameter or how this differs from similar URL-status tools. There is no output schema and no annotations, so the description is not complete enough for confident invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds little beyond the schema, though 'public library docs URL' loosely maps to the `url` parameter. It does not clarify why the other eight parameters are present or which one should be used for the status check.

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: returning the HTTP status for a public library docs URL. This is clear on its face, though it does not distinguish the tool 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?

No guidance is given about when to use this tool versus alternatives such as fetch-status, normalize-url, or web-fetch. The description does not mention exclusions, preferred parameter, or context, leaving the agent to infer usage from the schema alone.

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

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

With no annotations, the description carries the full burden. It discloses that values are discarded, but says nothing about whether the count is top-level only, how invalid JSON is handled, what is returned, or whether any memory/caching effect exists despite the 'memory' 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, no filler, and the main action is 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?

There is no output schema or annotations, and the description does not specify the return format or edge-case behavior. The broad input schema with many unrelated-looking optional params makes it unclear which parameter to populate, so the tool is not fully self-contained.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no parameter-level detail, but the json parameter's schema description identifies it as the JSON input; however, with nine optional parameters, the description does not clarify that json is the key one.

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 ('Count keys in a JSON object') and adds a meaningful scoping detail ('Values discarded'). It is clearly differentiated from sibling validate-json by its counting focus, though it does not explicitly name any alternative.

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

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

No guidance on when to use this tool versus validate-json or other shape-check siblings. The intended use is inferable from the name, but the description provides no explicit context, exclusions, or alternatives.

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

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

With no annotations, the description carries the burden. It clearly discloses that query and fragment are dropped, which is a key behavioral trait. It does not mention behavior for invalid URLs or whether other supplied parameters are ignored, though schema descriptions note several are discarded.

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

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

Two short sentences, front-loaded with the output and then the key transformation. No filler or redundant 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?

The return value is described conceptually, which is important because there is no output schema. But the nine-parameter schema includes many unrelated optional parameters, and the description does not explain their relationship to URL normalization; the schema's 'discarded' notes only partially fill that gap.

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

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

Schema coverage is 100% and each parameter has its own description. The tool description adds no parameter-specific meaning beyond identifying the URL as the input, 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 names the resource (URL) and the exact produced fields (origin, host, path), plus the transformation (query/fragment dropped). This distinguishes it from sibling URL tools that check status or shape.

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

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

The use case is implied: call it when you need the normalized origin/host/path of a URL. However, it does not explicitly say when not to use it or point to alternatives such as browser-url-ok or fetch-status for reachability checks.

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

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

With no annotations, the description bears the full burden of behavioral disclosure, and it does add one useful behavior: 'No browser is launched.' It does not disclose whether a network request is made, what side effects occur, or what 'can be opened' means operationally, 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 filler, and the key behavioral differentiator ('No browser is launched') is placed right after the main action. It is appropriately sized for what it attempts to convey.

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 9 optional parameters, no output schema, and no annotations, the description explains almost none of the operational context. It does not mention what the tool returns, how it handles the many non-URL parameters, or when it should be used, making the definition incomplete for reliable invocation.

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

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

Schema description coverage is 100%, so the baseline applies; each of the 9 parameters already has a meaningful description in the schema. The description itself adds no parameter-level meaning, such as which parameter is required for the URL check.

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 whether a URL can be opened') and immediately disambiguates from the sibling browser-url-ok by asserting 'No browser is launched.' However, it does not reflect the schema's broader set of accepted shape inputs (city, json, path, zone, etc.), leaving some ambiguity about the tool's exact scope.

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 'No browser is launched' implies a lightweight alternative to browser-url-ok, but it never names that or any other sibling explicitly. There is no guidance on when to choose this tool over fetch-status, normalize-url, or web-fetch, so usage context is only implied.

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

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

With no annotations, the description must carry the full transparency burden. It does disclose that the query is discarded, but it does not clarify whether the other eight accepted parameters are ignored, validated, or acted upon, nor does it describe the return value or confirm there are no other side effects.

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

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

The description is two short, front-loaded sentences with no filler. The action comes first, and the side-effect note about the query being discarded is a justified second sentence.

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

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

Even if the core operation is simple, the tool accepts nine optional parameters, has no annotations, and has no output schema. The description does not say which parameter is the query, whether the other parameters are ignored, or what the tool returns, leaving too much ambiguity for correct invocation.

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

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

Schema description coverage is 100%, so all parameters are already documented in the schema; the description adds little beyond equating the input with a search query and noting it is discarded. That is helpful but not enough to exceed the baseline for a fully covered schema.

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

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

The description uses a specific verb and object, 'Count characters in a search query', which clearly identifies what the tool does. It stops short of a 5 because it does not differentiate from counting siblings such as memory-key-count or hn-front-count, and the resource is described only generically as 'search query'.

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 a related sibling, no preconditions, and no exclusions. The agent must rely on inference from the tool name and the single-line description.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It implies a read-only, informational tool, but says nothing about output format, whether specific codes can be looked up, or how the seven input parameters affect the result. The schema's 'discarded' notes hint at behavior, but the description alone is insufficient.

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 redundant words, and the core resource is front-loaded. It is appropriately compact, though the brevity contributes to the lack of guidance in other dimensions.

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

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

The tool appears simple, but the definition leaves the seven-parameter input schema unexplained and does not describe the return shape or whether a status-code lookup is possible. With no output schema and no annotations, an agent cannot confidently determine what arguments to pass or what result to expect.

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

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

The schema has seven optional string parameters with descriptions, so coverage is high, but those descriptions are unrelated to a catalog of HTTP status codes (normalize URL, validate JSON, check file path, weather hint). The tool description adds no parameter information and does not explain which, if any, parameters should be supplied. This is a significant semantic mismatch despite 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 clearly identifies the resource: common HTTP status codes, and indicates the tool provides a catalog of them. This distinguishes it from siblings like web-fetch and fetch-status, which are network/status-checking tools rather than reference catalogs. However, it is a noun phrase rather than a concrete action statement, so it does not fully specify what an agent should expect the tool to do with an input.

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 or web-fetch. The description gives no context, preconditions, or exclusions. An agent is left to infer that this is a reference tool based on the word 'catalog'.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does disclose that the prompt is discarded and implies a side-effect-free, read-only-like operation. However, it does not explain that all nine parameters are effectively ignored beyond validation, nor what happens to the inputs with respect to retention.

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

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

The description is very short and front-loaded with the core purpose. Both sentences earn their place, though the brevity leaves some behavioral and contextual 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?

There is no output schema and the description does not describe the format or content of the returned 'three-step thinking template'. With nine parameters, no annotations, and no return details, the description is too thin for an agent to fully anticipate the tool's behavior.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no new parameter meaning and the 'Prompt discarded' note does not correspond to a named parameter 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 clearly states a specific action and resource: return a three-step thinking template. This distinguishes it from the sibling shape-check and validation tools, although it does not explain what the template contains.

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 statement 'Return a three-step thinking template' gives a result but not a situation, trigger, or reason for selecting it over siblings.

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

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

With no annotations, the description carries the disclosure burden. It communicates a read-only time lookup, but does not mention invalid timezone handling, return format, or that the many unrelated schema fields are effectively 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, front-loaded sentence with no filler or redundant information. 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?

Given no annotations, no output schema, and a schema with nine optional parameters, this description is too thin. It does not state that the iana parameter is the relevant one, what happens if it is omitted, or what the returned time format looks like.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds a slight semantic cue by saying 'named IANA timezone,' which maps to the iana parameter, but it does not clarify that the other eight optional parameters are not needed.

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's purpose: returning the current time for a named IANA timezone. This distinguishes it from sibling tools like utc-time and iana-zones, though it stops short of explicitly naming alternatives.

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

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

The IANA qualifier implies when the tool should be used, but there is no explicit guidance about alternatives or when not to use it. The description does not route the agent between timezone, utc-time, and iana-zones.

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

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

There are no annotations, so the description carries the full burden. It does not disclose that all parameters are discarded, nor does it explicitly state that the tool is side-effect-free. While 'current timestamp' implies a read-only operation, the presence of seven seemingly irrelevant parameters creates confusion that the description does not address.

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 zero filler. Every word contributes to the core 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?

While the tool itself is simple, the large input schema with parameters that are all discarded creates a mismatch that the description does not resolve. An agent might reasonably think it needs to supply a URL or city to get the timestamp, and the description lacks any clarification that these are irrelevant.

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

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

The input schema has 100% description coverage for its parameters, each explicitly stating it is discarded. The tool description adds no parameter-related 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 'Current UTC timestamp' states a specific verb (returns the current UTC time) and a clear resource. It distinguishes itself from siblings like timezone and iana-zones, which deal with timezone data rather than the current timestamp.

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

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

No guidance is provided on when to use this tool versus alternatives such as timezone or iana-zones. The description only states what the tool does, with no mention of contexts, exclusions, or preferable alternatives.

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

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

The description adds a useful behavioral detail: the body is discarded after the check. With no annotations provided, it does not fully cover other behavioral aspects such as return value or side effects, but it does disclose non-retention of input.

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

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

The description is two short sentences with no wasted words. The purpose is front-loaded and the disposal behavior is stated as a concise additional 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?

The definition is too sparse for reliable invocation: it does not specify which parameter represents the body, what the tool returns, or how to handle invalid JSON. The cluttered seven-parameter schema and absence of an output schema make this gap more significant.

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 detailed descriptions for all parameters, including the json parameter which clearly says it is the JSON text to validate. The description adds little parameter-level meaning, leaving it to the schema to identify the relevant field among several less relevant options.

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 resource: checking whether a body is valid JSON. It is more than a tautology and is distinguishable from sibling validation tools by its JSON focus, though 'body' is somewhat undefined.

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 JSON validity needs to be checked. However, it provides no explicit guidance about when not to use it or how it relates to sibling validation tools like file-path-ok or domain-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?

With no annotations, the description carries the full burden of behavioral disclosure, but it only mentions the external data source and the temperature output. It does not describe return formatting, whether an external API call occurs, or how the many unrelated optional parameters are treated. The schema hints that several fields are 'discarded,' but the description does not clarify 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 a single focused sentence with no wasted words and the key information front-loaded. It earns a high score for brevity, though it sacrifices some useful context that would have made the tool easier to invoke correctly.

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 what to expect, but it only provides a minimal purpose statement. The presence of nine optional parameters and multiple 'discarded' fields is unexplained, leaving an agent uncertain about return values and whether other parameters are ignored or meaningful.

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 meaning beyond the schema, and the schema's other eight parameters seem unrelated to the stated weather purpose, creating potential confusion that the description does not resolve. At least the city parameter is clearly relevant.

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

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

The description states a specific action and object: retrieving the current temperature for a city using Open-Meteo. It is clear and immediately recognizable, though it does not distinguish this hint tool from sibling hint tools like geo-hint or lib-docs-hint.

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

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

No guidance is provided about when to use this tool over alternatives, nor are any exclusions or preferences stated. The agent must infer from the name and one-line description that it is only suitable for weather-related city temperature lookups.

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

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

With no annotations, the description carries the full burden, and it does transparently disclose that only status and content type are returned and that the body is discarded. It stops short of covering redirect behavior, error handling, timeouts, or authentication requirements, leaving some behavioral ambiguity for a network-touching tool.

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

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

The description is two short sentences with no filler. The primary outcome is front-loaded, and the key limitation 'Body discarded' is stated succinctly.

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

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

The schema exposes nine optional parameters across unrelated domains (git refs, cities, JSON, timezones, queries), but the description only explains the public-URL use case. An agent cannot tell how to invoke the tool for the other parameters or what response shape to expect, and there is no output schema to fill the gap.

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

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

Schema description coverage is 100%, so the input schema already documents all nine parameters. The tool description adds no parameter-level meaning and does not explain whether the non-URL parameters are supported by this tool or how they relate to the stated URL-focused 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 verb and resource: fetch a public URL and return its HTTP status and content type. It also adds a key differentiator with 'Body discarded,' which separates it from a full-fetch tool. However, it does not explicitly distinguish itself from the sibling fetch-status, so the differentiation is only partial.

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 web-fetch versus alternatives like fetch-status, browser-url-ok, or playwright-url-ok. The only constraint mentioned is 'public URL,' which implies a limitation but does not explain when this tool should be preferred over its siblings.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure. It only says 'Title discarded after the call,' which hints at privacy/no persistence, but it does not state return type, whether network access to Wikipedia occurs, or what 'exists' means (e.g., redirects, case sensitivity).

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 extra retention statement is meaningful for a read-only check.

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 incomplete for an agent: there is no output schema, no return-value description, and no mapping of the stated 'Wikipedia title' to any input parameter. The mismatch between description and schema leaves critical information missing for correct invocation.

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

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

The description does not explain which parameter receives the Wikipedia title, and the schema properties are all unrelated: ref, url, city, feed, host, json, and path. The schema descriptions are individually detailed but none represents a 'Wikipedia title,' so an agent cannot correctly invoke this tool from the definition.

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

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

The description states a clear specific task: 'Check whether a Wikipedia title exists.' This distinguishes it from generic URL/path/JSON validators among the siblings. However, it does not clarify how the title maps to any input schema property, which slightly weakens the clarity.

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 this tool over siblings such as normalize-url, validate-json, or file-path-ok. The purpose implies 'use when needing Wikipedia title existence,' but no explicit context, prerequisites, 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.