ISO country GF

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 does disclose that task text is discarded, which is privacy-relevant, but it does not say whether remote network calls, paid API usage, or other side effects occur, nor does it address authentication, rate limits, or failure behavior.

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

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

The description is one compact sentence that front-loads the core purpose and then lists concrete outputs. Every clause adds information, including the 'Task text discarded' safeguard. It is slightly cryptic due to the unexplained 'Monid' term, but there is no redundancy or filler.

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

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

The tool has 9 optional parameters, no annotations, and no output schema, yet the description only mentions the tool's purpose and returned artifact names. It does not explain what Monid is, how inputs relate to the search, what the response format looks like, or what side effects to expect, leaving an agent with significant ambiguity for 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 schema already explains each parameter's role. The description itself adds no parameter-level meaning and fails to clarify which of the nine optional parameters is relevant to the tool's stated purpose, but it is not required to compensate given the 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 states a specific action ('Find') and a specific resource ('a public pay-per-call tool gateway (Monid)'), and lists the returned artifacts: CLI setup, how-it-works, skill file, and remote MCP hops. This gives enough identity to separate it from the utility-checker siblings, though 'Monid' and 'pay-per-call tool gateway' are not explained.

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 finding Monid gateway information, but it provides no explicit when-to-use or when-not-to-use guidance and names no alternatives. The caveat 'Task text discarded' is a constraint, not a usage directive, and none of the 27 siblings are referenced for comparison.

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 a single negative ('No browser is launched'). It does not say whether the tool makes a network request, what 'opened' means operationally, whether inputs are persisted, or what the return value indicates.

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

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

The two sentences are lean, front-loaded, and contain no filler. However, for a tool with no annotations, no output schema, and nine parameters, this brevity crosses from concise into underspecified, so it is not fully 'appropriately sized.'

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 leaves major gaps: no return format, no success/failure semantics, no clarification of whether the URL is fetched, and no explicit relationship between the URL check and most schema parameters. Given the large sibling family, an agent cannot confidently invoke or interpret this tool from the description alone.

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

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

Schema description coverage is 100%, so the parameter descriptions already explain each field and the description adds no parameter-level meaning. The main gap is that the tool description singles out a URL while the schema presents eight other unrelated optional inputs; however, the schema itself provides enough per-parameter context to meet 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 states a clear action and object ('Check whether a URL can be opened') and adds the useful constraint that no browser is launched, but 'can be opened' is left undefined—syntax validation, HTTP reachability, and renderability are all plausible. It also ignores that the schema exposes nine heterogeneous parameters (ref, city, json, query, etc.) that are described as discarded or validated, so the description does not accurately scope what the tool accepts.

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 choose this tool over nearby siblings such as fetch-status, normalize-url, web-fetch, or playwright-url-ok. The 'No browser is launched' note implies a contrast with a browser-based check but does not state conditions or exclusions.

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

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

With no annotations, the description carries the full burden, and it only discloses that the expression is discarded. It does not state what is returned, whether there are side effects, what operators are supported, or how the result is communicated.

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

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

The description is short and front-loaded, but it is under-specified rather than appropriately concise. The second sentence 'Expression discarded' adds little operational value and does not compensate for the missing parameter semantics.

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?

Without an output schema or annotations, and with a serious mismatch between the described behavior and the input schema, the definition is far too incomplete. It omits the expression parameter, return behavior, and usage context, so an agent cannot reliably select or invoke this 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?

Although the schema describes all nine parameters, none of them represents an arithmetic expression, and the description does not map the promised 'a+b style' input to any of them. An agent cannot determine which parameter to populate to evaluate an expression, making the tool effectively unusable 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 first sentence names a concrete verb and resource: 'Evaluate a+b style arithmetic.' This is specific enough to suggest an arithmetic evaluation operation and is not easily confused with sibling tools. However, the second sentence 'Expression discarded' is ambiguous and no alternative tool is named for differentiation.

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

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

There is no guidance on when to use this tool versus alternatives. The description implies arithmetic evaluation is the intended use, but it does not explain prerequisites, exclusions, or when a sibling tool would be more appropriate.

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

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

With no annotations provided, the description carries the behavioral transparency burden. It discloses one meaningful behavior: page content is not stored. It does not mention whether the tool fetches the URL directly, whether network access or authentication is required, or what side effects may occur.

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

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

The description is two short sentences with no filler. The main return contract is front-loaded, and the non-storage note is the only additional sentence, which 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 states the return values, which is necessary because no output schema exists. However, given the large number of optional parameters and the presence of several closely related sibling tools, the description lacks enough guidance about which parameter to use and when this tool is the right choice.

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 almost no parameter-level detail. The description aligns with the 'url' parameter but does not explain how the other nine optional parameters relate to the stated 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 names a specific output group—host, scheme, and HTTP status—for a URL, so the tool's core purpose is clear. It does not explicitly contrast itself with close siblings like fetch-status or normalize-url, so it stops short of full sibling 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?

The description implies the tool is for retrieving host, scheme, and HTTP status for a URL, which gives some usage context. However, it does not say when to prefer this tool over web-fetch, fetch-status, normalize-url, or other sibling URL-related tools.

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

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

The description discloses that 'No identifiers are retained', which is a useful privacy-related behavioral trait. However, with no annotations present, the description carries the full burden of explaining side effects, network usage, output format, and classification behavior. It does not say whether the tool is read-only, what it returns, or what 'classified' means operationally.

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

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

The description is short and front-loaded with the main action, but it is under-specified for a tool with 9 optional parameters. While there is no wasted wording, the brevity reduces usefulness because critical information about the classification result is absent.

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

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

Given 9 optional parameters, no output schema, and no annotations, the description is severely incomplete. An agent cannot determine what classification categories exist, what response to expect, or why one parameter might be preferred over another. The single sentence leaves too much unresolved for practical 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%, with each of the 9 parameters already having a clear description. The tool description itself adds no parameter-level meaning beyond the general privacy statement, so it does not need to compensate for missing schema details. Baseline of 3 is appropriate.

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

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

The description states a verb ('Show') and a resource ('how this request is classified'), giving a basic sense of what the tool does. However, 'classified' is vague and does not specify the classification scheme or how this relates to the tool's name 'compatibility'. It also does not distinguish itself from the many sibling tools, such as domain-shape or validate-json.

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 any of the sibling tools. The description does not mention any conditions, prerequisites, or alternatives, leaving the agent to guess whether 'compatibility' is a general request classifier or a specific validator.

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 transparency burden. It states the transformation and explicitly disclaims WHOIS/ownership lookups, which is useful. However, it does not describe error behavior, side effects, or clarify that only the host parameter is meaningful, leaving some 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 one active sentence with no filler. 'Split a hostname into labels' is front-loaded, and the negative qualifier adds useful scoping without bloat.

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 optional schema, no annotations, and no output schema, this one-sentence description is thin. It does not specify the return format, explicitly identify which parameter to use, or describe behavior for invalid hostnames. An agent can infer 'host' from the schema, but the description itself leaves too much to guesswork.

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

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

The input schema has 100% parameter description coverage, so the baseline is 3. The tool description adds no parameter-specific detail beyond identifying the hostname as the thing to split; the schema's per-parameter 'discarded' notes already handle the rest.

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

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

The description uses a specific verb and resource: 'Split a hostname into labels.' The qualifier 'without WHOIS or ownership data' clarifies the non-goal and distinguishes this from domain-lookup tools. It does not explicitly name a sibling tool, but the core purpose is unmistakable.

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' gives a weak when-not-to-use signal, implying this is only for syntactic hostname splitting. However, there is no explicit statement about when to choose this over related siblings like normalize-url, browser-url-ok, or other shape-validation tools, nor any mention of 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?

The description discloses the HTTP method (HEAD), the scope (public URLs only), and the result (status only), which is meaningful with no annotations available. However, it does not mention redirects, timeouts, error behavior, or whether the status is an HTTP code or a boolean, so transparency is only partial.

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

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

The description is a single front-loaded sentence with no filler. It conveys the core action and output efficiently, though it may be too terse given the large, ambiguous input schema.

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

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

Given a nine-parameter optional schema, zero annotations, no output schema, and many sibling tools, one sentence is not enough. The description does not specify which parameter to pass, what the returned status looks like, or how fetch-status relates to the sibling URL-checking tools, leaving significant gaps for an agent trying to call 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?

Although schema description coverage is 100%, the description does not clarify which of the nine optional parameters are relevant to fetch-status. It implies that 'url' is the key input, but it never says the other parameters (city, feed, json, path, zone, query, host, ref) are ignored or inapplicable, and the url parameter's schema description ('normalize or cite') conflicts with the tool's HEAD-status purpose.

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

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

The description clearly states the verb (HEAD), the resource (a public URL), and the result (return status only). It is specific and readable, but it does not distinguish fetch-status from sibling tools like browser-url-ok or playwright-url-ok, both of which may also check URL availability.

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

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

The description gives no explicit guidance about when to use this tool versus alternatives. 'Return status only' hints that this is a lightweight check, but it never names a sibling or states conditions for choosing fetch-status over web-fetch, browser-url-ok, or playwright-url-ok.

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

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

No annotations are provided, so the description must carry the behavioral burden. The only disclosed behavior is 'Path discarded,' which is ambiguous: it could refer to the URL path or to the 'path' parameter in the schema. There is no mention of what the tool returns, whether it validates, or how it handles malformed URLs.

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

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

The description is very short and front-loaded, with no filler words. However, it is under-specified and 'Path discarded' is cryptic, making it less useful than a slightly longer, clearer description would be.

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

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

Despite having 9 parameters and no output schema, the description provides almost no contextual information. It does not explain expected inputs, return values, or the relationship between the Figma URL and the many unrelated-looking schema properties, leaving an agent unlikely 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 parameters are individually documented. However, the description adds no parameter-level meaning and does not connect the Figma URL purpose to any specific parameter, such as 'url.' This meets the baseline for high schema coverage but does not go beyond it.

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 verb 'parse' and the resource 'Figma file URL,' so an agent can tell this tool is specifically for Figma URLs. The phrase 'Path discarded' adds some scope, but it does not explicitly say whether this is a validation, extraction, or normalization tool, and it does not contrast with sibling tools.

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

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

There is no guidance on when to use this tool instead of related siblings like normalize-url, browser-url-ok, or file-path-ok. The only contextual hint is the phrase 'Figma file URL,' but no alternatives, exclusions, or conditions 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 provided, the description carries the full disclosure burden, and 'No disk access' is a genuinely useful trait: the call is filesystem-safe and has no side effects. However, it never states the check's criteria (what makes a path unsafe?) or the return contract (boolean? error text?), which are critical gaps for a predicate tool that has no output schema to fill them.

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

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

Two sentences and 11 words, with the primary action front-loaded and the key behavioral qualifier second; there is no filler, no repetition, and every token earns its place. This is exemplary concision.

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

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

This tool has 9 heterogeneous parameters, 26 siblings, no annotations, and no output schema, so the description alone must communicate scope, criteria, and return semantics. It discloses only the no-disk-access trait, leaving the validation criteria, result type, and which of the 9 inputs it applies to unstated — too thin for the context it operates in.

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

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

Schema description coverage is 100%, with every one of the 9 parameters individually explained (e.g., 'JSON text to validate; discarded after the check'), so the schema already carries the parameter semantics and the baseline is 3. The description adds nothing parameter-specific beyond the generic word 'path', which matches the schema's 'File path to check' but no more.

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 — 'check whether a path looks safe' — and adds the qualifier 'No disk access', which separates it from network/disk-accessing siblings like web-fetch, fetch-status, and browser-url-ok. It does not define what 'safe' means, and it ignores the schema's seven other input kinds (url, json, zone, city, feed, host, ref, query), so the description under-sells the tool's actual surface; that scope mismatch keeps it from a 5.

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

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

The only guidance is the implication, via 'No disk access', that this is a cheap side-effect-free pre-check, but there are no explicit when-to-use or when-not-to-use conditions and no alternatives are named. With 26 siblings including near-neighbor validators (wiki-title-ok, normalize-url, browser-url-ok), an agent gets no help routing between 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 burden of explaining behavior. It reveals an external dependency on Open-Meteo and the output type, but it does not disclose how the place is specified, what happens on failure, whether network calls are made, or any rate-limit or data-handling concerns.

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 concise, front-loaded sentence with no filler. It is efficient, though slightly under-specified given the tool's broad input schema.

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

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

The tool has nine optional parameters, no required parameters, no output schema, and no annotations, but the description only provides a one-line summary. The agent cannot confidently determine which parameter represents the place or what the response format will be, so 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 the baseline is 3. The description adds no extra parameter-level meaning and does not identify which of the nine optional parameters should be used to provide the place, making it harder for the agent to know whether to pass 'city' or another field.

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

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

The description clearly states the tool produces latitude and longitude for a place via Open-Meteo, so the core purpose is understandable. However, it lacks a direct verb like 'Get' or 'Return' and does not differentiate itself from sibling tools such as weather-hint.

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

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

Usage is only implied: use this when you need coordinates for a place. The description does not state when not to use it, nor does it mention alternatives like weather-hint for weather data or timezone for timezone data, leaving the selection boundary 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says only 'Parse owner and repo' but does not state whether this is a local shape check, whether invalid or non-GitHub URLs fail, what it returns, or that the other schema parameters are discarded after the call.

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

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

The description is a single front-loaded sentence with no filler. It is concise and easy to read, though the under-specification of behavior and the nine-parameter schema mean it is not a fully informative description.

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

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

With no annotations, no output schema, and a nine-parameter schema covering many discardable inputs, the description is far too thin to let an agent call the tool correctly for anything beyond the url param. It gives no return-value shape, no error behavior, and no explanation for the non-url inputs.

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 fact that the url parameter is parsed for owner and repo, but it does not clarify how the other eight parameters relate to the stated purpose. The schema descriptions already document each parameter individually, so the description adds only marginal meaning beyond the schema.

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

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

The description names a specific verb ('Parse') and resource ('owner and repo from a GitHub URL'), which clearly differentiates it from sibling shape tools like figma-url-shape or jira-key-shape. However, the input schema exposes nine unrelated parameters (city, feed, host, json, path, zone, query), so the description only describes one slice of the tool's actual interface and undermines full 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?

The GitHub URL phrasing gives a weak implication of when to invoke this tool: when you need owner/repo from a GitHub URL. But it provides no explicit when-to-use or when-not-to-use guidance, and no alternatives are mentioned, so an agent cannot distinguish it from normalize-url, web-fetch, or browser-url-ok for URL tasks.

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 is the sole source of behavioral disclosure. It does reveal that titles are discarded and that the count is of 'current' front-page stories, which is useful. However, it does not disclose whether the tool performs a network fetch, how it handles failures, whether all parameters are discarded, or whether the count has any limits. This is a significant gap for a tool with no annotation coverage.

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 action is front-loaded, and the second sentence adds useful output-scope information without redundancy.

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

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

Given the lack of an output schema and annotations, the description should explain what the tool returns and how its inputs matter. It only says 'Count' and 'Titles discarded.' The nine optional parameters are left disconnected from the HN-specific purpose, and there is no guidance on whether to pass any of them. This is incomplete for a tool with this much input-surface area.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds no parameter-level detail, but the schema descriptions already mark each parameter as discarded or checked and none are required. An agent can reasonably infer that an empty call is valid. Still, the description does not clarify whether any parameter, such as 'feed', changes the source or outcome, leaving a minor but real semantic gap.

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

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

The description states a specific action and resource: 'Count current Hacker News front-page stories.' The added 'Titles discarded' clarifies that the result is a count only, not a list of titles. This distinguishes the tool from siblings like web-fetch or search-query-len, which have different purposes.

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, and no mention of when not to use it. The primary use case is inferable from the description, but the nine-parameter schema introduces ambiguity: the description does not say whether parameters are required, optional, or ignored, nor does it point to a sibling like web-fetch for fetching titles.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It is a noun phrase with no statement of what the tool does, what it returns, whether it is read-only, or what side effects—if any—exist. Even the basic operation is left implicit.

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

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

The description is compact and front-loaded, but it is under-specified rather than efficiently complete. A single phrase without a verb is not appropriately structured for a tool definition, even though there is no wasted filler.

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

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

With no annotations, no output schema, and multiple parameters, a one-phrase description is far from adequate. It does not explain how to invoke the tool, what the parameters are for, what the return value looks like, or how it relates to sibling tools.

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

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

Schema description coverage is 100%, so the baseline is 3. The schema already documents each parameter, though many are described as being discarded. The description adds no extra parameter meaning and does not clarify how these parameters relate to IANA timezone names, but the high schema coverage prevents a lower score.

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

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

The description identifies the tool's content as 'Common IANA timezone names' and ties it to 'clock calls', but it lacks an explicit verb such as 'returns' or 'lists'. It is not a pure tautology, but the agent must infer the operation, and it does not clearly distinguish this from sibling tools like timezone or utc-time.

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 weak contextual hint, but there is no explicit guidance on when to use this tool versus alternatives. With siblings like timezone and utc-time present, the agent cannot reliably decide which tool fits a given request.

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 mentions 'public' and 'group counts only,' which implies read-only behavior and limited output, but it fails to clarify which parameters are used, what counts as a group, or how errors/failures are handled.

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

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

The description is a single, efficient sentence with no fluff. It is front-loaded with the primary action and output scope, though it could benefit from a second sentence clarifying parameter usage.

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, this description is far too thin. It does not explain how to construct the target URL, which parameters are actually relevant, or what 'group counts' looks like in the response, making correct invocation uncertain.

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

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

Although schema coverage is 100%, the parameter descriptions are generic and appear shared across many sibling tools (e.g., 'url' says 'normalize or cite', 'city' mentions weather). The description does not map the robots.txt fetch to a specific parameter, leaving an agent uncertain whether to pass 'url', 'host', or 'path'.

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: fetch a public robots.txt and return group counts only. It is distinct from sibling tools by name and scope, though it does not explicitly differentiate itself from nearby fetch-related 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?

No guidance is given on when to use this tool versus alternatives like web-fetch or fetch-status. The description implies the use case through its name and one-liner, but it does not state prerequisites, exclusions, or how it differs from other fetching 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?

The description adds the behavioral note 'Key discarded,' which suggests the input is not retained. No annotations are present, so the description carries the full burden of disclosing side effects, return behavior, and error conditions. It does not state whether the check is a pure validation, whether it performs network access, or what happens for invalid shapes.

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

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

The description is very short, front-loaded, and free of filler. Both sentences are purposeful: the first identifies the operation and the second discloses disposal of the key. It is concise, though it skips important details that would make it genuinely helpful.

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 no annotations, yet the tool description does not explain the return value, accepted key format, error behavior, or which input parameter to use. Given the mismatched input schema, the description is not complete enough for an agent to invoke the tool confidently.

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

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

The input schema has descriptions for each property, but none obviously correspond to a Jira issue key, and the tool description does not map its purpose to any specific parameter. The schema lists ref, url, city, feed, host, json, and path with unrelated semantics, so an agent cannot confidently determine what to pass. The description fails to add the needed connection between 'Jira key' and the schema.

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

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

The description states a specific verb and resource: 'Check a Jira issue key shape.' This distinguishes it from sibling shape-checking tools like domain-shape or github-repo-shape. However, it is terse and the input schema does not clearly expose a 'key' parameter, so some ambiguity remains.

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

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

The phrase 'Check a Jira issue key shape' implies when to use the tool: when validating a Jira issue key. But the description provides no explicit comparison to alternatives, no exclusions, and no guidance about which schema field to populate, so an agent must infer the intended usage.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose one relevant trait (the body is discarded), but it does not explain whether a network request is made, how redirects/errors are handled, what status values can be returned, or any other side effects. A public network probe would benefit from more explicit 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 short, front-loaded, and contains no filler: both clauses carry information. It loses a point for being under-specified rather than deliberately complete, but as a concise fragment it is efficient.

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

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

For a tool with no output schema, no annotations, and nine parameters, a one-sentence description leaves major gaps: it does not describe the return format beyond 'HTTP status', does not explain the role of the other schema fields, and does not disambiguate from closely related siblings. The 'Body discarded' detail is helpful but does not make the tool contextually 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?

Schema description coverage is 100%, so the individual parameter meaning is already fully present; baseline 3 applies. The description adds no extra parameter semantics and even appears to reference only the URL case while the schema contains eight other unrelated fields, but it does not have to restate 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 clear outcome ('HTTP status') and a target resource ('a public library docs URL'), and adds a meaningful boundary with 'Body discarded'. This is specific enough for an agent to grasp the core action, though it does not differentiate the tool from sibling fetch/status tools such as fetch-status, browser-url-ok, or web-fetch.

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

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

'Body discarded' provides an implicit usage hint: use this when only the HTTP status is needed, not page content. However, the description never names alternatives like web-fetch or fetch-status, nor does it state when this tool should not be used, leaving the guidance largely 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 a key trait: 'Values discarded' means the values of keys are ignored. However, it does not say whether the count is top-level only, what the return value looks like, or whether there are any side effects, so it is only partially 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 two short sentences, front-loads the core action, and contains no filler. Every word earns its place.

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

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

Although the tool is simple, the definition is incomplete given nine optional parameters, no annotations, and no output schema. The agent is not told which fields to populate, what the response will contain, or how this tool fits with the numerous 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?

The schema already documents all nine parameters at 100% coverage, so the baseline is 3. The description does not clarify which parameter should carry the JSON object or how the parameters relate to the count, so it adds no meaningful parameter guidance beyond the schema.

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

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

The description uses the specific verb 'Count' on a clear resource, 'keys in a JSON object.' This cleanly distinguishes the tool from sibling validation tools like validate-json or domain-shape, since it is about counting rather than checking 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?

There is no statement about when to prefer this tool over alternatives or any exclusions. The sibling list contains several JSON and shape-related tools, but the description gives no routing guidance.

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

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

No annotations are present, so the description carries the burden. It explicitly discloses a non-obvious output behavior (query and fragment are dropped) and implies a read-only operation by saying 'return'. It does not discuss failure modes or side effects, but none are strongly suggested.

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 primary purpose is front-loaded and the second sentence adds a valuable behavioral constraint.

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 high schema coverage, the tool has nine optional parameters and no output schema, and the description does not explain the return format (separate fields vs. string) or reconcile the URL-focused description with unrelated parameters like city, json, and zone. An agent cannot fully predict invocation results.

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 bit of meaning for the url parameter (query and fragment are dropped), but it does not clarify the many unrelated optional parameters (city, json, zone, etc.) or which are actually consumed.

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?

Description states a specific verb (return), resource (URL), and concrete outputs (origin, host, path), with a distinct behavioral note (query/fragment dropped). This clearly distinguishes it from URL-checking siblings like browser-url-ok or figma-url-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: use when you need the origin, host, or path of a URL. However, there is no explicit guidance about when not to use it or when a sibling tool (e.g., a URL validation tool) would be more appropriate.

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

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

With no annotations, the description carries the full disclosure burden, but it only reveals that no browser is launched. It does not state whether a network request occurs, whether reachability is truly verified, whether there are side effects, or what the output shape is, making the core behavior 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 a clean two-sentence structure with no filler and the primary behavior stated first. It is appropriately short for a simple check tool, though it could use one more sentence on what 'opened' means.

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 heterogeneous parameters, no annotations, and no output schema, a one-line description is not enough for an agent to confidently invoke the tool correctly. The description does not clarify which parameter is required for the URL check, what the result represents, or how the non-URL parameters are used.

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

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

Schema description coverage is 100%, so the baseline is 3 and the schema already documents each parameter. The description adds no information about how the nine parameters relate to the URL-open check, but it does not need to compensate for missing schema docs.

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 action ('check') and resource ('URL'), and the second sentence adds an important differentiator from browser-launching tools. However, 'can be opened' is left undefined – it could mean syntax validation, DNS resolution, or actual page-load success – so it is not fully specific.

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' statement implies this is a lightweight alternative to browser-url-ok, but no explicit when-to-use or when-not-to-use guidance is given. It does not mention alternatives or exclusions, leaving the agent to infer the intended context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does state that the query is discarded, which is helpful, but it does not reveal that the tool accepts eight other optional parameters and what happens to them, nor does it describe output, errors, or side effects beyond discarding the query.

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

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

The description is extremely short and front-loaded: the core function is stated first, and the discard behavior is second. Every sentence earns its place, though the terseness sacrifices useful 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?

Given nine optional parameters, no annotations, and no output schema, this description is too thin. An agent cannot determine which parameter is the intended 'search query', what the output looks like, or how the other parameters should be handled. The description needs more operational detail to be 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?

Schema description coverage is 100%, so the baseline is 3. The description itself adds no parameter-level meaning; it does not even explicitly map 'search query' to the 'query' property. The schema descriptions do the necessary work, and the description contributes little beyond the tool's general intent.

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

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

The description states a specific action and resource: count characters in a search query. This is distinctive among the sibling tools, which are mostly URL, fetch, or validation utilities. It does not explicitly name sibling tools, but the functionality is clear enough.

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

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

No guidance is given about when to use this tool versus alternatives, nor when not to use it. The description does not explain whether this is for validating query length, logging, or some other workflow, leaving the agent to infer the intended 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?

No annotations are provided, so the description carries the full burden, but it only says 'short catalog' and reveals no side effects, return format, or whether network access occurs. The param descriptions mention discarded values, but the main description does not disclose 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 short and free of filler, but 'short catalog' largely restates the tool name. Conciseness is achieved at the expense of behavioral and usage context that would actually help the agent.

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

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

With seven seemingly unrelated parameters (ref, url, city, feed, host, json, path) and no output schema, the description leaves the tool's purpose and invocation ambiguous. It is not sufficient for an agent to select or call the tool correctly.

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

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

The description adds no parameter-level meaning, but the input schema already documents all seven parameters, some with explicit disposal notes. Baseline 3 applies because the schema handles 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 is a noun phrase, 'Short catalog of common HTTP status codes,' with no clear verb or operation. It does not specify whether the tool lists, looks up, or validates status codes, and it does little to distinguish it from siblings like fetch-status.

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

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

There is no guidance on when to use this tool versus alternatives such as fetch-status or web-fetch. The description implies a static reference use case but never states it explicitly or excludes live-status 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 full behavioral burden. It explicitly states 'Prompt discarded', signaling the input is not used, and the schema descriptions echo this for each parameter. However, it does not disclose whether the returned template is identical across calls or describe the template's format, which would further aid transparency.

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

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

Two short sentences, front-loaded with the core purpose, followed by a behavioral caveat. There is no filler or repetition; 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 trivial tool whose parameters are all discarded, the description plus schema is nearly sufficient. However, the absence of any output schema or description of the template's contents, and no explicit statement that all inputs are ignored (only 'Prompt'), leaves minor ambiguity. Adequate but with a clear 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?

All eight parameters have individual descriptions in the schema (100% coverage), so the baseline is 3. The tool description itself says nothing about parameters and adds no meaning beyond what the schema already provides, so it stays at 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 states a clear verb ('Return') and resource ('a three-step thinking template'), and the note 'Prompt discarded' clarifies the tool does not consume the input. This distinguishes it from sibling shape-checkers like domain-shape or validate-json, which return validation results rather than a template.

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

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

No guidance is given on when to invoke this tool versus any sibling. It does not mention alternatives like validate-json or normalize-url, nor any conditions that would select think-steps. The agent must infer intended use from the name and vague 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 behavioral burden. It states the core read-like behavior and the IANA scope, but it does not disclose output format, error behavior for invalid zones, or which of the nine schema fields actually drive the lookup. This is adequate for a simple lookup but leaves 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 seven-word sentence with no filler. The core information is front-loaded and immediately usable, so the concise structure is appropriate.

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

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

The schema covers the parameters, and the sibling set is enough to resolve purpose, but the description is too short to explain the return value format or that only 'zone' matters among the many optional parameters. For a simple lookup with no output schema, this is just 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 coverage is 100%, so the parameter descriptions already document every field, including the IANA zone parameter. The tool description adds no extra meaning about how to supply the zone or that other fields are irrelevant, so the baseline 3 applies.

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

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

The description identifies the resource ('current time') and the scope ('named IANA timezone'), making the tool's function clear even without a verb. It also distinguishes it from sibling utc-time and iana-zones, though it does not explicitly name those alternatives.

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

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

The description implies the usage scenario—get the current local time for a specific IANA zone—but it does not state when to choose an alternative such as utc-time for UTC or iana-zones for zone lists. There are no explicit exclusions or when-not-to-use 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?

No annotations are present, so the description carries the full burden of behavioral disclosure. Yet it only states the primary output without mentioning that the numerous input parameters are discarded or that the tool is stateless. The schema hints at discard behavior, but the description itself is silent, leaving the agent unaware of side effects or the irrelevance of 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?

The description is a single concise sentence that is easily parsed and front-loaded. It is appropriately short for a simple time tool, though it could benefit from a note about parameters. While sparse, it is not verbose or repetitive.

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

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

The description is incomplete given the tool's actual interface: a large input schema that is entirely discarded. Without a statement like 'ignores all parameters' or 'call with no arguments', an agent may unnecessarily populate unrelated values or become confused by the schema. The schema itself partially compensates, but the description does not resolve the mismatch.

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

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

The input schema already provides detailed descriptions for all seven parameters, including explicit 'discarded' notes. The description adds nothing about parameters. Since schema coverage is essentially 100%, the baseline of 3 is appropriate; the description neither compensates nor detracts.

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' clearly states the tool's function: it returns the current UTC time. The verb is implied but the resource is specific and unambiguous. It does not explicitly differentiate from sibling tools like 'timezone' or 'iana-zones', but the name and description are clear enough for basic identification.

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. There is no mention of prerequisites, contrast with timezone-related tools, or indication that all input parameters are optional/ignored. An agent receives no help choosing between utc-time and timezone/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?

Annotations already mark the tool as read-only, non-destructive, and idempotent. The description adds a meaningful behavioral disclosure beyond those annotations: the body is discarded rather than persisted or used further. It does not contradict 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?

The description is extremely concise and front-loads the core purpose. Both sentences earn their place, though the brevity contributes to missing usage and return-value 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?

With no output schema, the description should state what callers receive (e.g., a boolean, success/failure status, or error details), but it does not. It also does not clarify which parameter carries the JSON body, leaving an agent unsure how to invoke the tool correctly.

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

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

The input schema provides descriptions for all parameters, including `json` as the JSON text to validate. The description adds little parameter-level meaning, as 'body' does not explicitly map to `json` or clarify which of the several parameters should be supplied.

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

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

The description clearly states the operation: checking whether a body is valid JSON. It differentiates this from sibling shape-checking tools by naming JSON syntax validation as the specific resource and verb.

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

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

There is no guidance about when to use validate-json versus any of the many sibling shape/status checkers. It does not mention alternatives, preconditions, or typical call contexts, leaving the agent to infer suitability from the name.

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

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

With no annotations, the description carries the full disclosure burden. It states the core behavior (returns current temperature) and external dependency (Open-Meteo), but omits units, return formatting, and behavior on unknown cities. This is a minimum-viable disclosure for a simple lookup 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?

One sentence, no filler, and the key discriminator ('for a city') is front-loaded. Every word contributes to the tool's meaning.

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

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

The description is adequate for a simple lookup, but no output schema and no annotations leave return format unspecified. The schema's nine optional parameters create ambiguity about which inputs are relevant, even though the city property is clear.

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 and the schema already describes each parameter. The description adds no parameter-level detail beyond 'for a city,' though the city parameter is easy to match from 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 names a specific resource (current temperature), a target (a city), and a data source (Open-Meteo), so the tool's job is unmistakable. It also distinguishes weather-hint from siblings such as geo-hint, timezone, and utc-time without needing to open the schema.

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

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

The description clearly implies the use case: whenever an agent needs the current temperature for a city. There are no explicit exclusions or alternative tool mentions, but the signal is strong enough because no sibling tool covers current weather.

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

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

With no annotations, the description carries the transparency burden; it discloses the key behavior that the response body is discarded and the output is limited to status and content type. It does not disclose redirect handling, error behavior, or whether any auth is needed, but for a public read-only fetch the core behavior is stated.

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, front-loading the main output and then stating the key limitation. It is appropriately concise for a simple tool, though it omits some context that other dimensions penalize.

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

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

For a 9-parameter tool with no annotations and no output schema, the description is minimally adequate: it states what is returned and what is discarded. It is incomplete for choosing among many similar sibling tools and for determining which of the many schema parameters actually affect the 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 description coverage is 100%, so each parameter has some textual meaning and the baseline is 3. The description itself adds no parameter-level guidance and does not identify url as the primary parameter among the nine optional fields.

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

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

The description states the tool's core function: it returns HTTP status and content type for a public URL. 'Body discarded' adds a clear scope boundary. It does not explicitly name or contrast sibling tools such as fetch-status, so it falls 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?

'For a public URL' gives a clear usage context and 'Body discarded' implies this is a lightweight check, not a content-retrieval tool. However, the description does not state when to prefer web-fetch over siblings like browser-url-ok or fetch-status, nor does it mention exclusions such as private or authenticated URLs.

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

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

With no annotations, the description carries the full burden. It adds the useful statelessness detail 'Title discarded after the call,' which clarifies that the input is not retained. However, it does not disclose the return shape, network behavior, or error handling for non-existent titles.

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 action, no filler. Every word contributes to either the purpose or the statelessness behavior.

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

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

For a simple existence check with no annotations and no output schema, the description is minimally adequate. It leaves implicit that the result is likely boolean and that only the 'wiki' parameter is relevant, which a more complete definition would state explicitly.

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

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

The input schema already describes each parameter, including 'wiki' as a 'Wikipedia article title to validate,' so schema coverage is high. The description adds the existence-check semantic beyond mere validation, but it never points to which parameter should be used.

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 Wikipedia title exists.' This clearly separates it from sibling shape-checkers like browser-url-ok or normalize-url, and the name reinforces the purpose without relying on the title 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?

No explicit when-to-use or when-not-to-use guidance is given, and no alternative tools are named. The intended use is implied by the purpose, but an agent must infer when to choose this over siblings such as fetch-status or web-fetch.

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