ISO country EC

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

There are no annotations, so the description must disclose behavior itself. It does disclose that 'Task text discarded' and lists the return artifacts, which is useful. However, it does not clarify whether the tool is fully read-only, performs network access, or has any cost/auth implications, which matters given the 'pay-per-call' framing.

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

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

The description is two short sentences with no filler. The purpose is front-loaded, and the second sentence efficiently covers outputs and data handling.

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 gives the core behavior and return values, but the 9-parameter input schema feels disconnected from the stated purpose. Since all parameters are discarded, the description could more explicitly say 'no meaningful input is required' or clarify why those params exist. Still, the essentials are present.

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

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

Schema description coverage is 100%, and each parameter already states that it is discarded or involves no disk access. The tool description adds no param-level meaning, so the schema carries the load, matching the baseline score of 3.

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

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

The description names a specific verb and resource: 'Find a public pay-per-call tool gateway (Monid).' It also lists the concrete outputs, so an agent can tell what the tool returns. It does not explicitly compare against sibling tools, but the named gateway and output artifacts are distinct enough to establish purpose.

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

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

The description implies a use case: use this tool when you need to locate the Monid pay-per-call gateway and its setup/skill files. However, it never states when not to use it, and it gives no explicit alternatives or conditions relative to the many sibling tools.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only reveals that no browser is launched. It does not state whether a network request is made, what the result looks like, whether redirects are followed, or how failures are reported. The schema hints that unrelated parameters are discarded, but the description itself is silent.

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

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

The description is two short sentences with no fluff, front-loading the core operation and then the key no-browser qualifier. It is efficient, though it is arguably too terse for a tool with nine optional parameters.

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

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

The agent still does not know what return value to expect, which of the nine optional parameters should be populated, or how this tool relates to sibling checking tools. Given the absence of an output schema and annotations, the description leaves too much to inference 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: every parameter is already documented, including explicit 'discarded' notes for decoy fields. The description itself adds no parameter guidance, and the 'url' parameter description mentioning 'normalize or cite' is somewhat inconsistent with the tool's stated purpose, which slightly weakens clarity.

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

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

The description states a specific operation: 'Check whether a URL can be opened.' It adds a useful qualifier, 'No browser is launched,' which helps separate it from a browser-driven check like playwright-url-ok. It stops short of a 5 because it never names the alternative or defines what 'can be opened' means in practical terms.

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

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

There is no guidance about when to use this tool versus siblings such as playwright-url-ok, web-fetch, or fetch-status. No prerequisites, exclusions, or alternative selection conditions are provided, 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, the description must carry behavioral disclosure. It does mention 'Expression discarded', which is a behavioral trait, but it doesn't say what is returned, whether side effects occur, or how the tool can both evaluate and discard the expression. The behavior is ambiguous at best.

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 are concise but under-specified for a tool with nine parameters and no output schema. The sentences also undermine each other ('Evaluate' vs 'discarded'), so brevity is not serving clarity.

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

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

This tool has nine parameters, no annotations, and no output schema, yet the description explains neither the return behavior nor which parameter carries the expression. The description leaves too many critical unknowns for an agent to safely call it.

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

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

The schema descriptions cover all nine parameters, so the baseline is 3, but the description adds no mapping from 'a+b style arithmetic' to any parameter; in fact, no parameter exists for an expression. This leaves an agent unable to know what to pass.

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

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

The description names a specific operation, 'Evaluate a+b style arithmetic', and is distinct from sibling validation tools, but it is self-contradictory: 'Expression discarded' suggests no evaluation actually occurs. It also doesn't map to the input schema, which has no arithmetic-expression parameter.

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

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

No guidance is given on when to use calc-eval versus any sibling tool, and no alternatives or exclusions are mentioned. The only implicit signal is the name and the arithmetic phrase, but the 'discarded' behavior makes even that unreliable.

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 to carry the behavioral burden, and the description discloses no behavior at all: no side effects, no read-only guarantee, no output format, no indication that most parameters are discarded. The word 'Public' hints at accessibility but does not explain what happens when the tool is invoked.

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

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

The description is a single, short, front-loaded phrase with no filler or repetition. It is concise, though brevity comes at the expense of substance.

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

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

For a tool with nine optional parameters, no output schema, no annotations, and no usage context, this one-line description is severely incomplete. An agent has no way to know what input matters, what the tool returns, or what 'record for EC' means operationally.

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 and the baseline is 3. The main description adds no parameter meaning, though the schema's parameter descriptions do clarify behaviors like 'discarded after the shape check' and 'no disk access'.

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

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

The phrase 'Public ISO 3166-1 record for EC' names a specific resource (a country-code record for Ecuador) and is not a tautology, but it lacks an explicit verb or operation such as 'returns', 'retrieves', or 'validates'. An agent can infer the subject but not confidently the action.

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 call this tool versus alternatives like geo-hint, iana-zones, or timezone. The description does not state use cases, exclusions, or how the nine optional parameters should be selected.

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

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

With no annotations, the description carries the behavioral transparency burden. It adds one meaningful fact—'Page content is not stored'—which signals a non-persistent inspection. However, it does not disclose network behavior, redirect handling, auth needs, or what happens for invalid 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?

Two short sentences, front-loaded with the core behavior and followed by one relevant limitation. Every sentence earns its place; there is no 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 required fields, no output schema, and no annotations, but the description only covers the URL case. It leaves the role of city, feed, json, path, zone, query, and ref unexplained in the tool-level description, and does not contextualize the tool against 27 siblings.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter syntax or relationship details, but the schema already documents each parameter. It does not clarify why the tool accepts many unrelated optional fields when the output is URL metadata, which slightly weakens 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 operation and output: 'Return host, scheme, and HTTP status for a URL.' This is clear and not a tautology. It does not explicitly distinguish from overlapping siblings like fetch-status or normalize-url, but it names exact return fields, so an agent can tell what the tool does.

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 fetch-status, normalize-url, or web-fetch. 'Page content is not stored' implies a limitation but does not state when to use or avoid the tool. With many overlapping siblings, this is a significant gap.

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

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

With no annotations, the description must disclose side effects. It mentions 'No identifiers are retained' and parameter notes like 'no disk access', but it does not explain what the tool actually does with the inputs, whether it makes network calls, or what the output is.

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 and parameter descriptions are concise, with no redundant fluff. However, the conciseness comes at the cost of clarity.

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

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

The tool has 9 optional parameters and no output schema, and the description does not explain what 'classification' means or what the tool returns. An agent would be unable to invoke it effectively without additional information.

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

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

All 9 parameters have descriptions, achieving 100% coverage, but the descriptions are terse and ambiguous (e.g., 'discarded after the shape check', 'to normalize or cite'). They provide some context beyond the type, but not enough to understand the tool's 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 'Show how this request is classified' is vague and does not specify what kind of classification is performed, what the tool does with the inputs, or how it differs from sibling tools. The verb 'Show' is weak, and the resource is unclear.

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

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

No guidance is provided on when to use this tool versus the many sibling tools. The description does not mention any context, prerequisites, or alternative tools.

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

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

No annotations are present, so the description carries the behavioral burden. 'Without WHOIS or ownership data' is a useful disclosure that no external ownership lookup occurs, but the description does not mention what the output looks like, how invalid hostnames are handled, or that the unrelated schema fields 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?

The description is a single, front-loaded sentence with no filler. Every word contributes meaning: the action, the target, and an important boundary of 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?

This tool has nine optional parameters, no annotations, and no output schema, yet the description is only one sentence. It leaves unresolved which parameter should be used and what the split result looks like, making it under-specified 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% and the 'host' field already describes a 'Public hostname', so the description adds little beyond what the schema provides. It does not explicitly instruct the agent to pass the host parameter or clarify the expected format, keeping it at the baseline.

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

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

The description uses a specific verb ('split') and resource ('hostname'), and the negative clause 'without WHOIS or ownership data' clarifies that this is a lexical operation, not a lookup. It is clear enough to distinguish from ownership-style tools, though it doesn't explicitly differentiate among sibling shape tools such as github-repo-shape or jira-key-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 guidance on when to use domain-shape rather than nearby siblings like normalize-url, github-repo-shape, or browser-url-ok. The description does not say which of the nine optional schema parameters to populate or what context this tool is intended for.

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 disclosure burden. It does disclose the HTTP method (HEAD), the 'public URL' constraint, and the status-only output, but it omits important behavioral details such as timeout/redirect behavior, output status format, what happens when non-URL parameters are passed, and whether any side effects or network calls occur for the other parameter types.

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 a clear verb, object, and output restriction. It is front-loaded and free of filler, though it is probably too short for the complexity implied by the nine-parameter schema.

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

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

Given the nine optional parameters, no output schema, no annotations, and a large sibling tool set, the description is incomplete. An agent does not know what the returned status looks like, how to select parameters for non-URL inputs, or when this tool is preferable to sibling tools like web-fetch or browser-url-ok.

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 an individual description, but the tool description itself mentions only URL. It does not explain whether the nine parameters are alternatives, combinable, or mutually exclusive, nor which parameter triggers the HEAD request. The schema descriptions hint at shape checks and discarded values, but the description adds no operational parameter semantics and may mislead an agent into thinking only 'url' is 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 names a specific action—HEAD a public URL and return status only—so it is not tautological. However, the input schema accepts nine disparate optional parameters (ref, city, feed, json, path, zone, query, etc.), suggesting a much broader multi-shape validation purpose that the description does not convey. It also does not differentiate this tool from sibling tools like web-fetch or browser-url-ok beyond the phrase 'status only'.

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

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

The description implies a use case: when you need only the HTTP status of a public URL via HEAD. But it provides no explicit guidance about when to choose this over related siblings such as web-fetch, browser-url-ok, playwright-url-ok, or validate-json, and no exclusion criteria or alternative routing.

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

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

With no annotations, the description carries the full burden. It reveals only that the path is discarded, but not whether the tool validates, extracts, or returns a boolean; nor does it mention side effects or requirements. The lack of output schema makes the behavior even more opaque.

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, which is concise, but the cryptic sentence 'Path discarded.' is not well-structured or sufficiently informative. It front-loads the main action but leaves key aspects ambiguous.

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

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

For a 9-parameter tool with no annotations and no output schema, this definition is grossly incomplete. It fails to explain the return value, which parameter to provide, or the criteria for a valid Figma URL. An agent would be guessing when selecting and invoking 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 schema coverage is 100%, the descriptions are generic and not tied to Figma; the `url` param is described as 'normalize or cite' rather than shape-checking. The description doesn't say which of the 9 parameters is relevant, and 'Path discarded' could be misread as the `path` param rather than the URL path. The schema alone doesn't resolve the ambiguity.

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

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

The description names a specific verb and resource: 'Parse a Figma file URL.' However, it doesn't clarify what 'shape' means or what the tool returns, and the added note 'Path discarded' is ambiguous. It does not explicitly distinguish this from sibling URL tools, though the Figma-specific resource helps.

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 choose this tool over siblings like normalize-url or browser-url-ok. The description doesn't state the intended input domain or any alternative/fallback conditions. Usage must be inferred entirely 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 provided, the description carries the full behavioral burden. 'No disk access' is a valuable disclosure indicating the tool cannot verify existence or permissions. However, it does not explain what 'safe' means, what return value the agent should expect, or whether specific path patterns are rejected, leaving important behavior undisclosed.

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

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

The description is very concise and front-loaded, with no filler words. However, it is slightly under-specified for a tool with no output schema, no annotations, and a nine-parameter interface, so it is not fully 'appropriately sized' despite its brevity.

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, and the description does not define 'safe,' state the return type, or clarify how the non-path parameters fit the tool's purpose. Sibling validators are not referenced, so an agent cannot distinguish this from URL, title, or JSON validators. The 100% schema coverage helps with parameter meaning but does not compensate for the missing behavioral and usage context.

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

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

Schema description coverage is 100%, so the baseline is 3; each property already has a meaningful schema-level description. The tool description adds no extra detail about path format or how the other eight optional parameters relate to this tool, relying entirely on 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 action ('check') and a specific resource ('path'), with 'looks safe' and 'No disk access' clarifying this is a shape-only validation rather than a filesystem operation. It does not explicitly contrast with sibling validators like browser-url-ok or wiki-title-ok, and 'safe' is left undefined, so it stops short of a top score.

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

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

No guidance is given about when to prefer this tool over alternatives such as browser-url-ok, normalize-url, validate-json, or wiki-title-ok. The only implicit cue is the word 'path,' which is too weak to reliably route an agent. There are no explicit when-to-use, when-not-to-use, or alternative tool mentions.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It only reveals that Open-Meteo is used; it does not mention that this is a network lookup, how unknown places are handled, whether inputs are discarded, or what the response format is.

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

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

The description is one short sentence with no redundant wording, so it is concise and front-loaded. It loses a point because the telegraphic phrasing omits enough context to be fully self-sufficient.

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

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

Given nine optional parameters, no output schema, and no annotations, a single sentence is insufficient for reliable invocation. The definition omits output format, error behavior, and which parameter is actually consumed, so an agent is left guessing.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description adds no parameter-level meaning. The relevant input is inferable from the schema (the city field), but the description does not point to it, and the schema also lists several unrelated optional fields, creating ambiguity.

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

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

The description identifies the output as latitude/longitude and names Open-Meteo as the provider, so an agent can infer this is a geocoding hint. However, it is a noun phrase rather than an explicit action statement, and it does not state what input is required or how it differs functionally from sibling tools like weather-hint or timezone.

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

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

The description gives no guidance about when to use this tool rather than an alternative. Nothing in the text says 'use when you need coordinates for a city' or excludes sibling tools that also handle place-related 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?

No annotations exist, so the description carries the full disclosure burden, but it only reveals a 'parse' verb with no mention of side effects, network access, return format, or the discard behavior repeatedly described in the schema ('discarded after the check'). The description's extraction framing ('parse owner and repo') also sits uneasily with the schema's validation-and-discard framing, leaving an agent unable to predict whether the tool returns a parsed object or a shape-check verdict. There is no annotation contradiction because no annotations were provided.

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 zero filler words; the verb, resource, and outcome all appear within the first six words. Every element earns its place, and nothing could be trimmed without losing information.

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

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

The tool has nine parameters, no annotations, and no output schema, so the description must carry substantial explanatory weight, but it covers at most one parameter's use case. It neither explains what the tool returns (critical given the missing output schema), nor reconciles the eight unrelated parameters with the GitHub-repo purpose, nor clarifies when siblings like validate-json, weather-hint, or iana-zones should be chosen over this tool. The description would be adequate for a hypothetical single-parameter tool, not the one defined by this schema.

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

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

Schema description coverage is 100%, establishing a baseline of 3, but the description actively adds a conflicting interpretation: it implies 'url' is a GitHub URL to extract owner/repo from, while the schema describes 'url' as an 'HTTPS URL to normalize or cite.' Eight of nine parameters (city, feed, zone, json, query, path, ref, host) have no connection to the description's stated purpose, and the description does nothing to help an agent understand which parameters are relevant or how they interrelate.

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') with a clearly identifiable resource ('a GitHub URL') and the expected extraction result ('owner and repo'), so an agent understands what the tool does. It does not explicitly differentiate from sibling shape tools (figma-url-shape, jira-key-shape, domain-shape) or normalize-url, and its narrow scope sits oddly against a schema covering nine unrelated input domains, but the stated purpose is unambiguous.

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

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

The description gives no guidance on when to use this tool versus the many siblings that could plausibly handle GitHub URLs — normalize-url, domain-shape, browser-url-ok, playwright-url-ok — or versus the rest of the shape-tool family. No exclusions, conditions, or alternative routing are provided; the only usage context is what is trivially implied by the phrase 'parse owner and repo from a GitHub URL.'

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does state that titles are discarded, which hints at the output shape, but it does not mention network fetching, failure modes, rate limits, or side effects. For a tool with nine optional parameters and no output schema, this is insufficient behavioral transparency.

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

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

The description is only two short sentences and is front-loaded with the core purpose. There is no filler, but 'Titles discarded' is a terse fragment that could be clearer about whether it refers to output content or input handling.

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 a confusing set of nine optional parameters, yet the description does not explain how to invoke it, what parameters matter, or what the return value looks like. The purpose is clear, but an agent would struggle to know how to call this tool correctly in practice.

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 covers 100% of parameters, so the baseline is 3, and the schema already gives each parameter a description. The main description adds no parameter-level meaning and does not clarify which of the nine optional parameters are actually relevant to counting HN front-page stories. Therefore it neither helps nor deeply harms parameter understanding.

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: 'Count current Hacker News front-page stories.' It names a specific verb, resource, and scope, and it is distinguishable from sibling tools like web-fetch or fetch-status. The phrase 'Titles discarded' adds a useful boundary, even though the long optional parameter list is not addressed.

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

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

The description implies the tool should be used when an agent needs the current Hacker News front-page story count, but it gives no explicit guidance on when not to use it or how it differs from alternatives. No sibling tool is mentioned, and no invocation context is provided beyond the basic purpose.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It hints at a list of timezone names but does not state what happens when called, what is returned, whether inputs are used, or whether the operation is safe. The input schema's mention that several parameters are 'discarded' is not integrated into 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 extremely short and free of filler, which is concise. However, it is under-specified to the point of being a label rather than an informative specification; conciseness is achieved at the expense of essential content.

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

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

With nine optional parameters, no annotations, and no output schema, the description should provide far more context. It does not explain what the tool returns, why such unrelated parameters exist, what 'clock calls' means in this context, or how an agent should use this tool correctly. The definition is seriously incomplete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning beyond the schema, and it notably does not connect the timezone-name purpose to any of the nine parameters, which appear unrelated to timezone selection.

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

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

The description is a noun phrase—'Common IANA timezone names for clock calls'—rather than an explicit statement of what the tool does. It essentially restates the tool name 'iana-zones' and offers no verb such as 'returns', 'lists', or 'validates', leaving the agent to guess the operation.

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 mild implied use case, but there is no explicit guidance about when to use this tool versus siblings like 'timezone' or 'utc-time', and no exclusions or alternative routing. It is borderline implied usage, not clear 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 provided, so the description carries the full burden. It does disclose that only group counts are returned, but it does not explain how the robots.txt URL is derived, what failures look like, whether network access is required, or what 'group counts' means in practice.

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, tight sentence with no filler and the output constraint is front-loaded. It is concise, though slightly under-specified for a tool with 9 parameters.

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

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

Given 9 optional parameters, no annotations, and no output schema, the description is incomplete. It does not say which parameter is required to locate the robots.txt, what a 'group' is, or how errors and edge cases 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?

The input schema has 100% description coverage, so the baseline is 3 even without param details in the description. However, the description does not clarify which of the 9 parameters identifies the robots.txt URL, leaving ambiguity between 'url' and 'host' for the caller.

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 ('Fetch'), resource ('public robots.txt'), and result ('return group counts only'). This is clear enough to identify the tool's core purpose, though it does not explicitly differentiate it from sibling tools like web-fetch or fetch-status.

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

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

There is no guidance about when to use this tool versus alternatives, and no mention of exclusions or prerequisites. With 26 siblings, an agent is left to infer when 'inspect-robots' is the right choice, which is insufficient.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It only says the key is discarded, which suggests statelessness, but it does not explain what a successful or failed shape check returns, whether any validation errors are raised, or whether outputs differ per input type. This is notably insufficient for a validation 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 refreshingly short, with no filler or redundant clauses. The two sentences are immediately readable and front-load the core verb and resource. The second sentence is somewhat cryptic and overlaps with the schema's repeated 'discarded' notes, but the overall brevity is a strength.

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

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

For a tool with nine heterogeneous parameters, no annotations, and no output schema, this description is severely incomplete. An agent cannot determine what value will be returned, which required fields are needed, whether multiple fields are validated simultaneously, or how it differs from the sibling shape/validation tools.

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

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

Schema parameter coverage is complete, with each of the 9 properties having a description, so the schema does the heavy lifting and earns the baseline of 3. However, the tool description itself adds no parameter-level meaning and never maps which field actually represents the 'Jira issue key' mentioned in the description. This ambiguity prevents a higher 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 names a specific verb and resource ('Check a Jira issue key shape'), which is clear enough against pure tautology. However, the tool's schema exposes nine unrelated fields (ref, url, city, feed, host, json, path), so it is unclear whether this tool checks only issue keys or multiple input kinds. 'Key discarded' hints at behavior but does not clarify the actual purpose 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 provided on when to use this tool versus sibling shape-checking tools such as domain-shape, github-repo-shape, figma-url-shape, or normalize-url. The description implies 'use when you need to check a Jira key shape,' but does not state exclusions, prerequisites, or how to choose among 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?

No annotations are present, so the description carries the burden of behavioral disclosure. It does state that the body is discarded and that HTTP status is returned, which is useful, but it omits details like HTTP method, redirect behavior, or whether any input is actually required.

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. Both sentences contribute meaningful information: the result (HTTP status) and a key behavior (body discarded).

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

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

Given nine optional parameters, no output schema, no annotations, and many related sibling tools, the description is under-specified. It does not explain which parameter is the URL to check, what response shape to expect, or how this tool relates to other HTTP-checking tools.

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

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

Schema description coverage is 100%, so the baseline is 3; the description does not need to restate parameters. However, the description's focus on "a public library docs URL" does not map cleanly to which of the nine optional parameters should be used, creating some ambiguity.

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

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

The description clearly identifies the core outcome: returning the HTTP status for a public library docs URL. It is understandable and specific, though it lacks a strong action verb and does not distinguish itself from sibling tools like fetch-status or browser-url-ok.

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

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

There is no guidance on when to choose this tool over alternatives such as fetch-status, browser-url-ok, or web-fetch. No exclusions, prerequisites, or recommended parameter combinations are provided, so the agent must infer 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?

There are no annotations, so behavioral transparency falls entirely on the description. 'Values discarded' is a useful trait and consistent with the schema's discard notes, but the description omits error behavior, whether nested keys are counted, and what 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 definition is two short sentences with the action front-loaded and no filler. 'Values discarded' earns its place by clarifying an important 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?

With no annotations and no output schema, the definition leaves critical gaps: all nine parameters are optional, none is identified as the JSON object to count, and the form of the result is not stated. An agent has to guess at the intended 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 adds no parameter-level detail, but schema descriptions cover all nine parameters, so the high-coverage baseline applies. The mapping is imperfect: the json parameter is described as text to validate, not as the object to count, though the parameter name makes it the most plausible input.

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

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

The description names a specific action (count keys) and resource (a JSON object), so the core purpose is clear and distinct from validation or length-count siblings. It does not pinpoint which JSON object is meant or explicitly contrast with siblings such as validate-json, so it is not a 5.

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

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

There is no guidance about when to call this tool, when not to call it, or which sibling tool would be a better fit. The only implied trigger is 'need a key count', and even then the description does not say what input to provide.

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 key behavioral trait: query and fragment are intentionally dropped. Since no annotations are provided, the description carries the burden, but it does not mention how invalid URLs are handled, whether the URL must be HTTPS, or that most of the nine schema parameters appear to be 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 that states the output and the key exclusion in a direct, efficient way. There is no unnecessary prose or repetition of schema contents.

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, non-mutating URL utility, the description gives the core behavior, but it lacks an explicit return format and does not address the large number of optional parameters or their relationship to the tool. With no output schema or annotations to fill these gaps, the description is adequate but not fully complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds useful context about the output and that URL query/fragment are removed, but it does not clarify which of the nine parameters are actually relevant or should be provided for normalization.

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

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

The description clearly states the verb ('Return'), the resource ('a URL'), and the specific outputs ('origin, host, and path'). It also differentiates the behavior from a generic URL fetcher or validity checker by noting that query strings and fragments are dropped.

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 this tool should be used when an agent needs a URL decomposed into origin, host, and path while discarding query/fragment. However, it does not explicitly name alternatives or state when not to use this tool versus siblings like browser-url-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. It does reveal an important non-obvious trait: no browser is launched. But it does not explain whether a network request is made, whether the check is purely structural, or what side effects, if any, occur. This is a meaningful but incomplete disclosure.

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, and the clarifying caveat about no browser is immediate. Every word earns its place.

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

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

The tool has 9 parameters and no output schema, yet the description only mentions URL checking and no browser launch. It does not explain what the tool returns, which parameter combinations are valid, or how the many unrelated schema parameters relate to the stated purpose. This leaves 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?

Schema description coverage is 100%, so the schema already documents every parameter individually. The description adds no additional parameter-level meaning beyond focusing on the 'url' concept. This matches the baseline expectation of 3.

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

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

The description names a specific action and resource: checking whether a URL can be opened. The added caveat 'No browser is launched' helps distinguish it from browser-based tools, though it does not explicitly name a sibling. The meaning of 'can be opened' is slightly ambiguous—syntactic validity vs. network reachability—so it stops short of a 5.

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

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

The description implies a use case: determine if a URL is openable without launching a browser. However, it gives no explicit guidance on when to prefer this over siblings like browser-url-ok, fetch-status, or normalize-url. The context is present but not clearly directional.

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 behavioral burden, and 'Query discarded' is a useful disclosure indicating the input is not retained. However, it does not clarify whether the operation is fully read-only, what happens to the other eight accepted properties, or whether any side effects occur beyond the count.

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

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

The description is two short sentences with no filler and the main action is front-loaded. Every word earns its place, making this an appropriately concise description for a simple counting tool.

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

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

With nine optional parameters, no output schema, and no annotations, the description is too thin for an agent to confidently invoke the tool. It does not specify the return format, whether `query` is effectively required, or whether the other parameters are ignored or cause errors.

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

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

The input schema already documents all nine parameters at 100% coverage, so the description adds little beyond specifying the query focus. The schema carries the semantic weight, and the description does not compensate with additional parameter-level detail.

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: count characters in a search query, which matches the tool name and the `query` parameter. It does not explicitly distinguish itself from sibling tools, but the resource is specific enough to convey the core purpose.

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

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

There is no guidance on when to use this tool versus alternatives like memory-key-count or validate-json, nor any exclusions or prerequisites. The schema's nine optional fields also make it unclear whether only `query` should be supplied or whether other fields are acceptable.

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. Calling it a 'short catalog' implies a read-only lookup, but it does not state whether the tool returns a list, accepts a status code parameter, or has any side effects. The input schema lists several parameters that seem unrelated to HTTP status codes, further muddying the 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 short sentence with no wasted words, which is efficient. However, it is under-specified: it leaves out important context about how the tool works and what it expects, making it more terse than genuinely concise.

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

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

Given the tool has seven parameters, no annotations, and no output schema, a one-line description is inadequate. The parameters (ref, url, city, feed, host, json, path) do not obviously map to 'HTTP status codes,' so an agent cannot confidently determine how to invoke the tool or interpret its result.

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

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

The schema provides descriptions for all seven parameters, such as 'discarded after the shape check' and 'HTTPS URL to normalize or cite,' so the schema already covers parameter meaning. The description adds no additional parameter semantics, and it does not explain how these parameters relate to the catalog of status codes.

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

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

The description clearly identifies the tool as a catalog of common HTTP status codes, so an agent can infer that it provides reference information about status codes. However, it lacks a explicit verb like 'returns' or 'looks up,' and it does not distinguish itself from the sibling tool fetch-status.

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

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

The description gives no guidance about when to use this tool versus alternatives. It does not mention alternatives, exclusions, or a preferred context, leaving the agent to guess whether status-catalog or a sibling like fetch-status is the right choice.

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 must carry behavioral disclosure. It usefully discloses that the prompt is discarded, suggesting the output is a fixed template rather than dependent on user input. However, it does not state whether any of the nine schema parameters are used or ignored, nor does it describe side effects or the template's structure, so the disclosure 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 very brief, front-loads the core purpose, and contains no filler. Each sentence adds something: the first states what is returned, the second adds behavioral context. It is concise rather than merely short, though the terseness does leave relevant details unstated.

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 input parameters, no output schema, and no annotations, the description is too thin to be fully actionable. It does not explain what the 'three-step thinking template' contains, how any of the input parameters affect the result, or why this tool should be chosen over its siblings. An agent could call it, but would be guessing about its behavior beyond the fixed template claim.

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

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

Schema description coverage is 100%, so the baseline of 3 applies even though the tool description adds no per-parameter detail. The 'Prompt discarded' line is contextually relevant but does not map to any specific schema property, and the description leaves the relationship between the nine parameters and the returned template unclear.

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

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

The description states a clear verb and resource: 'Return a three-step thinking template.' It also adds a distinguishing behavioral note, 'Prompt discarded,' which signals that the tool is not an input-processing utility. It is specific enough to separate it from the surrounding shape-check and fetch-style sibling tools, though it does not explain what the three steps are.

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 stated preconditions or exclusions. The intended use is only implied by the purpose: call it when you want a three-step thinking template. For a tool with many sibling utilities, more routing context would be helpful.

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 states only that the tool returns a current time; it does not say that all other parameters are ignored/discarded, whether timezone validation occurs, or what output form to expect. The schema's 'discarded' notes hint at behavior, but the description itself is silent.

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

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

The description is a single front-loaded sentence with no filler. Every word contributes to stating the operation.

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

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

The tool has 9 optional parameters, no output schema, and no annotations, so the description needed to do more than one sentence. It does not explain the role of the many optional parameters, how to specify the timezone, or what happens with invalid input. This is adequate only for an extremely simple call and under-serves an agent given the schema's complexity.

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 describes all 9 parameters (100% coverage), so the baseline is 3 and the description does not need to restate their semantics. However, the description does not help identify which parameter actually selects the IANA timezone, leaving that to schema inference.

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 names the resource (a named IANA timezone) and the expected result (current time), and it is distinct from siblings like iana-zones and utc-time. It lacks an explicit verb such as 'get' or 'return,' so it is not a full 5, but the intended operation is unambiguous.

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

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

The phrase 'current time in a named IANA timezone' implies when the tool is appropriate, but it does not mention alternatives or exclusions. Siblings like utc-time and iana-zones occupy nearby territory, and the description gives no route to choose among 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 alone must disclose behavior. It only names the output and does not explain that all input parameters are discarded, that the tool is read-only, or what format the timestamp uses. This is a meaningful transparency gap.

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

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

The description is extremely short and front-loaded, with no wasted words. It is concise, though the brevity comes at the cost of 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?

There is no output schema and no annotations, so the description should specify return format and whether arguments are meaningful. It does neither, and the presence of nine unrelated optional parameters makes the tool's actual behavior less obvious than it should be.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The tool description adds nothing about parameters, but the baseline is acceptable when the schema carries the semantic weight.

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 output: a current UTC timestamp. It is a noun phrase rather than a verb+resource construction, and it does not explicitly differentiate from siblings like timezone or iana-zones, but the core purpose is unambiguous.

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

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

There is no guidance about when to use this tool versus alternatives, and no mention of the nine optional parameters even though they all appear to be ignored. An agent has to infer that this tool is only for getting the current UTC time.

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

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

No annotations are present, so the description carries the full behavioral disclosure burden. The statement 'The body is discarded' usefully signals that the input is not persisted, but the description does not disclose return format, failure behavior, or whether any other side effects exist.

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

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

The description is extremely concise and front-loaded: the first sentence states the purpose and the second adds a key behavioral detail. There is no filler, though slightly more precision about the input parameter could have made it stronger.

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

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

For a simple validation tool, the description is minimally adequate, but there is no output schema and no mention of what the tool returns. The many unrelated optional parameters in the schema also add ambiguity that the description does not resolve.

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 seven parameters have descriptions in the schema, so the high schema coverage baseline applies. The tool description itself adds no parameter-level meaning and uses the vague term 'body' instead of aligning with the `json` parameter.

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 operation ('Check') and the resource ('valid JSON'), which distinguishes it from sibling URL/domain/path validators. The word 'body' is slightly imprecise and does not explicitly map to the `json` parameter, so it is not a perfect 5.

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

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

There is no guidance about when to use this tool versus alternatives, nor any statement about when not to use it. The intended usage is only implied by the tool's name and the description.

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

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

There are no annotations, so the description carries the full burden of explaining behavior. It says 'via Open-Meteo', which suggests an external call, but it does not disclose failure behavior, rate limits, response shape, or what 'discarded after the call' means for the city parameter. The behavioral context 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?

The description is a single short sentence with no wasted words, so it is concise. However, for a tool with nine parameters and no annotations, this brevity is under-specification rather than effective compression. It front-loads the core idea but omits context needed for correct invocation.

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

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

With no annotations, no output schema, and nine parameters, the description is far too thin to give an agent complete guidance. It does not explain which of the nine optional parameters to provide, why so many unrelated parameters exist, what the response looks like, or whether an external network call is required. The agent is left to guess the intended call shape.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds only that 'city' is the relevant input, while the schema itself describes the other eight parameters as mostly discarded or irrelevant. This leaves the tool's actual parameter selection ambiguous, so the description does not meaningfully improve parameter understanding beyond the schema 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 the tool returns current temperature for a city and names the data source (Open-Meteo), making the core purpose reasonably clear. It is not a tautology and is more specific than the bare name. However, it does not distinguish itself from the sibling 'geo-hint' tool, which could plausibly overlap.

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 city-based weather lookups but gives no explicit guidance on when to choose it over alternatives like 'geo-hint' or 'web-fetch'. There are no stated exclusions, prerequisites, or conditions that would help an agent route to this tool reliably.

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, and it does disclose an important behavioral trait: the response body is discarded. It does not mention redirects, error behavior, content-type representation, or any rate/auth constraints, so the disclosure 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?

Two short sentences, front-loaded with the core outcome and followed by the most important discard behavior. Every word earns its place.

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

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

The tool has nine optional parameters and no output schema, so the description needs to explain the overall shape of what this tool accepts and why unrelated-looking parameters like city, feed, json, and zone are present. The current description only covers URL fetching and leaves the rest of the interface unexplained.

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

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

Schema description coverage is 100%, so the schema documents all nine parameters; the description need not repeat them. The description does not add meaning beyond the schema, and it actually under-specifies the tool's scope by mentioning only URLs while parameters include city, feed, JSON, path, zone, and query.

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 operation as returning HTTP status and content type for a public URL and explicitly says the body is discarded, which is concrete and helps orient an agent. It does not, however, distinguish web-fetch from closely related siblings such as fetch-status, browser-url-ok, or playwright-url-ok.

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

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

The phrase 'public URL' and 'Body discarded' imply use for lightweight metadata checks and caution that content will not be returned, but there is no explicit when-to-use/when-not-to-use guidance or reference to alternatives. The intended choice versus fetch-status or browser-url-ok is left 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?

The description does disclose one behavioral trait: 'Title discarded after the call,' which tells the agent the input is not persisted. With no annotations provided, however, it leaves other important behaviors unclear, such as whether a live Wikipedia lookup occurs, what the result looks like, and whether all the other schema parameters 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?

The description is tightly written with the main purpose front-loaded and no filler. The second sentence adds a behavioral note that earns its place. It is concise, though slightly under-specified for an input schema with eight heterogeneous parameters.

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

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

For an eight-parameter schema with no output schema, a two-sentence description is not enough to let an agent call the tool correctly. It never states which parameter is the Wikipedia title, what a positive or negative result means, or whether the other schema fields are relevant. The definition leaves too much for the agent to guess.

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

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

Every input schema property has its own description, so schema coverage is high and the description would only need to add marginal value. But the description references a 'title' parameter that does not exist in the schema, while the actual parameters (ref, url, city, feed, host, json, path) are described in terms of other purposes. This creates real ambiguity about which property should be populated.

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

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

The description states a concrete operation: 'Check whether a Wikipedia title exists,' which names both the action and the resource. It is clear on a high level and the tool name reinforces the Wikipedia-title focus. However, it doesn't differentiate this from sibling validation tools, and the schema contains no 'title' property, creating a purpose-to-schema mismatch.

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 sibling alternatives like validate-json, normalize-url, or web-fetch. The description offers no 'use when' conditions, no exclusions, and no pointer to a better alternative. Usage context is only weakly implied by the tool name.

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