ISO country SV

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

The description discloses the pay-per-call nature (a cost implication), states that task text is discarded, and enumerates the return contents. It does not describe any side effects, auth, or rate limits, but for a lookup/gateway tool the disclosed behavior is fairly informative given zero annotations.

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

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

Two short sentences, each carrying distinct information: the lookup action+outputs, and the task-text behavior. There is no filler, and the key purpose is front-loaded. The cryptic phrase 'Task text discarded' is compact but the description earns its length.

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 does not explain how the six diverse parameters (ref, url, city, feed, host, json) should be supplied or which one elicits the gateway info. With no output schema and no usage context, an agent cannot confidently know whether to pass one, some, or all parameters. The individual schema descriptions help, but the overall invocation contract remains vague.

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

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

The input schema already provides 100% descriptive coverage of all six parameters. The tool description adds no additional meaning about how the parameters relate to the lookup or what values select the gateway. Baseline 3 is appropriate because the schema carries the parameter details.

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 (Find) and a named resource (public pay-per-call tool gateway Monid), and lists the concrete outputs (CLI setup, how-it-works, skill file, remote MCP hops). It distinguishes the tool from the sibling list by describing a unique lookup function. The odd note 'Task text discarded' introduces slight ambiguity but does not obscure 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?

No explicit guidance on when to use this tool instead of a sibling. The only indirect hint is that the tool finds a Monid gateway, but no condition or alternative is named. The 'Task text discarded' note warns that task text is ignored, but that is not a positive selection criterion.

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 important side-effect fact ('No browser is launched'), but it does not say whether the tool makes network requests, whether it is read-only, or what happens with the many non-URL parameters.

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

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

Two short sentences with no filler; the no-browser clarification earns its place. It is concise and front-loaded, though slightly undersized for the apparent complexity of the 9-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?

The tool has a large parameter surface, no output schema, and many sibling tools, so the description should explain the shape-check nature, how the parameters relate, and what the result looks like. It only gives a one-line purpose and a negative side-effect note, leaving too much for the agent to infer.

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 individual parameters already carry their own semantic descriptions. The tool description itself adds no parameter-level meaning and does not explain why parameters like city, feed, json, or path appear under a URL-checking tool, but it does not need to repeat 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-ish purpose: 'Check whether a URL can be opened,' and adds that no browser is launched, which gives some distinction from playwright-url-ok. However, 'can be opened' is vague about whether this is syntactic validation, reachability, or browser compatibility, and it does not mention the heterogeneous input fields such as ref, city, feed, json, and path.

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

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

There is no explicit guidance about when to use this tool instead of siblings like normalize-url, fetch-status, web-fetch, or playwright-url-ok. The negative clause 'No browser is launched' implies a lightweight check, but it does not state selection criteria or alternatives.

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

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

With no annotations, the description carries the full burden, but it only says 'Expression discarded' without defining what the tool returns, what side effects exist, or how evaluation behaves. Even the one behavioral note is confusing because no expression parameter exists in the schema.

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

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

The description is very short and front-loads the core action in the first sentence. However, it is under-specified to the point of being unhelpful, and the second sentence about discarding the expression adds little because no expression input is defined.

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 incomplete. It does not explain what to pass, what the result looks like, or how this tool is meant to be used, making it nearly impossible for an agent to invoke correctly.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description adds no parameter-level meaning. The description's reference to an 'expression' is not matched by any schema property, so it does not improve 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 says 'Evaluate a+b style arithmetic,' which states a verb and a resource type. However, the input schema contains no expression parameter at all, so the stated purpose does not match the actual tool inputs. It also does not distinguish calc-eval from related validation/evaluation siblings.

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, no exclusions, and no mention of prerequisites. The phrase 'a+b style arithmetic' only weakly implies a calculator use case, but it is not enough for an agent to confidently choose this tool over siblings.

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

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

No annotations are present, so the description carries the full behavioral disclosure burden. It only says 'Public', giving no information about side effects, return values, authentication, or the fate of the many provided parameters. The schema's per-parameter 'discarded' notes help but are not tool-level 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 technically short, but brevity without substance is under-specification, not effective conciseness. A noun phrase with no verb gives the agent no actionable 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?

For a tool with 9 optional parameters, no annotations, no output schema, and many related sibling tools, a single vague phrase is severely incomplete. The agent cannot determine what the tool returns, what inputs are expected to be used together, or what 'record for SV' actually means 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?

Schema description coverage is 100%, so every parameter already has a clear description. The tool description itself adds no parameter meaning, but the baseline of 3 applies because the schema does the heavy lifting.

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

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

The description names a resource ('ISO 3166-1 record for SV') but states no verb or action, so it is unclear whether the tool returns, validates, or simply represents the record. It does not differentiate itself from sibling shape/hint/lookup tools.

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

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

There is no guidance about when to use this tool or when to prefer one of the many sibling tools. The word 'Public' hints at accessibility but does not establish any selection criteria.

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 and does disclose that 'Page content is not stored.' It implies a read-only inspection by saying 'Return,' but omits other relevant behavior such as whether the URL is fetched live, what inputs other than url do, or any rate/error 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 with the core result, and adds a meaningful privacy/behavioral note about page content not being stored. Both sentences earn their 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 optional parameters, no output schema, and several similar sibling tools, yet the description only addresses URL-host-scheme-status behavior. It does not explain how the other parameters relate to the tool, what the return format is, or why this tool should be chosen over a sibling.

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

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

Schema description coverage is 100%, so the input schema already documents each of the 9 parameters. The description adds only the 'for a URL' framing and does not clarify the many non-URL parameters in the schema, but the schema already covers their individual meanings.

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: 'Return host, scheme, and HTTP status for a URL.' This is clear and actionable, though it does not explicitly contrast with sibling tools such as fetch-status or normalize-url.

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

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

There is no guidance on when to use this tool versus alternatives like fetch-status, browser-url-ok, or normalize-url. The description implies URL inspection, but does not state exclusions or conditions that should route an agent to another sibling.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It adds 'No identifiers are retained,' which is a meaningful privacy behavior. However, it does not clarify whether input is transmitted externally, whether there are side effects, or what the classification process actually does beyond that one guarantee.

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 compact and front-loaded: the main action comes first, followed by a useful privacy note. There is no filler or repetitive content, so every sentence earns its place.

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

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

The description is not complete enough for a tool with 9 parameters, no output schema, no annotations, and many similar siblings. It does not describe the classification output format, which inputs are relevant, or when this tool should be preferred over related validation/shape tools.

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

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

Schema description coverage is 100%, so each parameter is already documented in the schema. The tool description adds no extra meaning about which parameters matter, how they interact, or which should be supplied for a particular classification.

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 gives a verb and object — 'Show how this request is classified' — so it is not a tautology. However, it never explains what classification is being shown, what categories or labels exist, or how this differs from the many shape/validation siblings like domain-shape, validate-json, and status-catalog.

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 versus any alternative. It only says it shows classification, with no mention of conditions, exclusions, or sibling tools. An agent would have to infer the intended use from the name and schema.

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

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

No annotations are provided, so the description must carry the behavioral burden. It only discloses the absence of WHOIS/ownership data and omits side effects, return behavior, error cases, or how unrelated schema parameters are handled. The schema's 'discarded' notes are structured data, not description credit.

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 sentence with no filler, and the key scope constraint is front-loaded. It is appropriately terse for a simple operation, though it does not reconcile the many unrelated schema 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 explain return values, which parameters are relevant, or how non-host inputs are treated, leaving too much for an agent to infer.

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 detail beyond implying the 'host' parameter is the main input; all parameters are already documented in the schema.

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

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

The description states a specific action ('Split a hostname into labels') and a clear boundary ('without WHOIS or ownership data'). It is not a tautology and helps distinguish from WHOIS/ownership lookups, though it does not explicitly reference a sibling tool.

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 when-to-use guidance or mention of alternatives. The 'without WHOIS or ownership data' clause hints at a narrow use case, but an agent is left to infer when to choose this tool over siblings like normalize-url or browser-url-ok.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does state the HTTP method (HEAD), the access scope (public URL), and the output scope (status only), which implies a read-only operation. But it does not explain how the nine optional schema parameters relate to the URL operation or what happens on redirects, timeouts, or errors.

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

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

The description is a single sentence with no filler. It front-loads the method and outcome, and every word contributes to the meaning.

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

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

With nine optional parameters and no output schema, the description is too thin to be fully actionable. It does not specify which parameter carries the URL, what the status return value looks like, or how to treat the many apparently unrelated optional parameters.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds only that a URL is being HEADed, but it does not map parameters or clarify why the schema includes many unrelated optional fields such as city, json, zone, and query. This leaves ambiguity about which parameters are actually 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 uses a specific verb and resource: 'HEAD a public URL' and narrows the result to 'status only.' This clearly distinguishes it from sibling tools like web-fetch or normalize-url, which fetch content or transform URLs rather than just reporting 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 usage is implied: use this tool when you need the HTTP status of a public URL without retrieving content. However, it does not explicitly name alternatives or state when not to use this tool, such as when page content or a full browser check is needed.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It does reveal a non-obvious trait: 'Path discarded,' which tells the agent that the path component is intentionally ignored. However, it omits other important behaviors such as whether the tool performs network access, returns a boolean, or produces a normalized result, leaving the agent with only partial transparency.

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

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

The description is two short sentences with no filler. 'Parse a Figma file URL.' states the core action, and 'Path discarded.' adds a crucial behavioral caveat. Every word earns its place, and the most important scoping information is front-loaded.

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

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

For a tool with 9 optional parameters, no annotations, and no output schema, this description is far too sparse. It does not explain what the parsed result contains, whether the url parameter is the primary input, or how the many unrelated parameters (city, feed, json, zone, query) should be handled. An agent cannot confidently know what to pass or what to expect in return.

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 detail. Each of the 9 parameters has its own schema description, including 'discarded after the check' for path and relevant notes for url and host. The description does not add meaning beyond those schema entries, 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 names a specific verb and resource: 'Parse a Figma file URL.' This clearly distinguishes the tool from generic URL tools and sibling shape checkers by naming the Figma domain explicitly. It loses a point because 'parse' is somewhat ambiguous—it doesn't state whether this means validation, normalization, or extraction—and it doesn't explicitly contrast with siblings like normalize-url 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 use this tool versus alternatives. It does not mention which sibling to prefer for non-Figma URLs, nor does it state any exclusions or prerequisites. The only implied usage is 'when you have a Figma file URL,' but no explicit routing or comparison is provided.

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

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

The description discloses the key non-behavior 'No disk access' and uses the hedged phrase 'looks safe,' signaling that this is a heuristic/syntactic check rather than a guarantee. However, it doesn't state what 'safe' means, what the return value looks like, or that inputs are 'discarded after the check'—that detail is left to the schema property descriptions.

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, and each one carries distinct information: the core purpose and the critical no-disk-access constraint. Nothing is redundant or padded.

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 contains seven heterogeneous optional parameters, yet the description doesn't explain which one to pass or whether they are mutually exclusive. There is also no output schema or mention of the return shape, so an agent has insufficient guidance to call the tool correctly based on the description alone.

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

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

Each input property already has a descriptive schema entry, so schema coverage is effectively 100% and the baseline applies. The description itself adds no parameter-level guidance, though the schema's 'File path to check' makes the intended path argument reasonably clear.

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

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

The description states a specific action ('Check') and a clear resource ('whether a path looks safe'), and the 'No disk access' qualifier distinguishes it from tools that inspect real files. However, it doesn't reference sibling validators or explain why the schema exposes six other unrelated fields such as url, city, feed, and json, which keeps it from being a 5.

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

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

No guidance is provided on when to choose this tool over alternatives like domain-shape, wiki-title-ok, or browser-url-ok. 'No disk access' implies a syntactic use case, but there is no explicit when-to-use, when-not-to-use, 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only mentions Open-Meteo and does not state whether the call is read-only, whether inputs are discarded, whether authentication is needed, or how errors behave.

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 front-loaded sentence with no wasted words, and the most important information appears first. It is compact, though adding a verb and a pointer to the relevant parameter would make it more useful without much length.

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 is a nine-parameter tool with no required parameters, no output schema, and no annotations, so a one-sentence description is not enough for reliable invocation. It does not specify the return format, which parameter contains the place, or what happens with the many seemingly unrelated parameters.

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

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

Schema description coverage is high at 100%, so the baseline is 3 even without parameter details in the tool description. However, the schema descriptions are generic and disposal-focused, and the description does not explicitly map 'a place' to the city parameter, leaving some ambiguity.

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

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

The description names a concrete output, latitude and longitude, and the data source, Open-Meteo, so an agent can infer this is a coordinate lookup tool. It lacks an explicit verb and does not differentiate from siblings, but the core purpose 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?

There is no when-to-use or when-not-to-use guidance, and the description does not reference any sibling alternatives or preconditions. The only clue is the name and output, which is not enough to route an agent confidently.

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 says 'parse' and does not disclose what happens with the many unrelated parameters, whether non-GitHub URLs error out, or what the result shape is. The schema hints that several parameters are discarded, but the tool description itself provides no transparency about these behaviors.

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 single sentence is front-loaded, direct, and contains no filler. It loses a point only because it omits contextual information that would help an agent handle the nine-parameter schema, though that omission is more relevant to other dimensions.

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

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

This tool has nine optional parameters, no annotations, and no output schema, so the description needs to clarify which parameters matter and what the tool returns. The description only covers the basic parse operation and does not explain that url is the only meaningful input or what the owner/repo result looks like, leaving an agent under-informed for correct invocation.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds important meaning by identifying the url parameter as the operative GitHub URL and clarifying that the expected extraction is owner and repo. This is more specific than the schema's generic 'HTTPS URL to normalize or cite' description.

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

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

The description 'Parse owner and repo from a GitHub URL' uses a specific verb, names the input resource (GitHub URL), and states the output (owner and repo). This clearly separates it from sibling tools like figma-url-shape, jira-key-shape, and domain-shape, which target different URL or key shapes.

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

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

The use case is implied: call this when you have a GitHub URL and need the owner and repo parsed out. However, there is no explicit guidance about when not to use it, nor any mention of the more specific sibling tools for other URL shapes, so the guidance remains implicit rather than explicit.

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 state that titles are discarded, which implies the output is only a count, but it does not explain whether the tool makes a live network request, whether the many optional parameters are ignored or used, or what the exact return value is. 'Titles discarded' adds some useful context but leaves major operational 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?

Two short sentences with no filler; the core operation is front-loaded and the 'titles discarded' caveat is a meaningful addition. Every word earns its place.

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

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

Despite a 9-parameter schema and no output schema or annotations, the description does not specify how to invoke the tool, the return type, or operational constraints. It is only a terse purpose statement, not a complete definition 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 coverage is 100% with all nine parameters described, so the baseline is 3; the description itself adds no parameter guidance. The schema descriptions are individually clear but not reconciled with the HN-count purpose, and the description does not say which parameters are relevant or that none are required.

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') and a specific resource ('current Hacker News front-page stories'), and 'Titles discarded' clarifies that the result is a bare count rather than story content. This is enough to distinguish it from fetch-style 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?

No guidance is given about when to choose this tool over alternatives such as web-fetch or fetch-status, and there is no mention of when not to use it. The use case is only implied by the action, not stated in terms of alternatives.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only names a resource. It does not state whether the tool is read-only, what it returns, or why the various parameters are accepted and discarded. The schema hints at discard behavior, but the description itself contributes no 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 brief and front-loaded, but it is under-specified: one noun phrase cannot carry the operational detail needed for a 9-parameter tool. Brevity alone is not enough when the content omits the action and usage context.

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

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

For a tool with nine optional parameters, no output schema, no annotations, and many siblings, the description is far from complete. It doesn't clarify the return value, when to call the tool, or why arbitrary parameters like ref/url/json are accepted. The schema helps, but the core semantics remain ambiguous.

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 even though the description adds no parameter-level detail. Each parameter has an individual schema description (e.g., 'discarded after the shape check'), though the top-level description does not explain why these parameters are relevant to a timezone-name tool.

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

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

The description 'Common IANA timezone names for clock calls' essentially restates the tool name without an action verb: it doesn't say whether the tool lists, returns, validates, or maps timezone names. It gives a vague category but does not distinguish iana-zones from siblings such as 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?

There is no when-to-use or when-not-to-use guidance and no mention of alternatives. The phrase 'for clock calls' implies some domain context, but it is too vague to help an agent choose between this tool and the timezone/utc-time siblings, especially given the many unrelated optional parameters.

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

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

With no annotations, the description carries the burden. It does disclose that the operation is a public read and returns only group counts, which is useful. But it does not describe failure behavior, network dependency, or what happens when no robots.txt exists.

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 constraint efficiently.

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 and no output schema, the description is too sparse. It fails to indicate which parameter identifies the robots.txt URL, how group counts are structured, or how to handle the many unrelated schema fields.

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 no mapping between parameters and the robots.txt target, leaving ambiguity about whether 'url' or 'host' is the relevant 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 states a specific action ('Fetch a public robots.txt') and a precise output scope ('return group counts only'). This clearly distinguishes it from generic fetching tools like web-fetch and from full-content fetch operations.

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 implied: use this when you need robots.txt group counts rather than the full file. However, the description does not name alternative tools or specify when not to use this tool, so the guidance is minimal.

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 transparency burden. It does disclose that the key is discarded, implying non-persistence, but it does not say whether the check is local, what it returns, how invalid shapes are handled, or whether any side effects exist beyond discarding the input.

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

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

The description is two short sentences with no filler. It front-loads the main purpose and then adds a useful behavioral note. Every word earns its place.

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

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

With no annotations and no output schema, the description needs to explain how to invoke the tool and what result to expect. It instead leaves a broad nine-parameter schema, never identifies the parameter for the Jira key, and never states the return value or validation behavior. This is not complete enough for confident correct invocation.

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

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

Although the schema has 100% parameter descriptions, none of the nine properties is named 'key' or described as a Jira issue key. The description's 'Key discarded' does not map cleanly to any schema property, leaving the agent uncertain which argument to pass. High schema coverage is undercut by the mismatch between the tool's purpose and the actual parameters.

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

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

The description names a specific verb and object: it checks the shape of a Jira issue key, and it adds that the key is discarded. This is clear enough to identify the tool's core purpose, though it does not distinguish it from sibling shape-checking tools or define what shape means.

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, no exclusions, and no mention of prerequisites. The only contextual hint is the name and the sentence, so an agent is left to infer appropriate 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?

No annotations are provided, so the description carries the burden. It discloses a key non-obvious behavior: the response body is discarded, so the tool returns only status. It does not mention redirects, timeout, or read-only guarantees, but for a simple status-check tool this is reasonable 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 wasted words. The main purpose is front-loaded, and the crucial 'Body discarded' caveat is stated separately and clearly.

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

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

Given no annotations and no output schema, the description plus the fully documented input schema is just enough to invoke the tool: provide an HTTPS URL and expect an HTTP status with no body. But the tool has nine optional parameters and many URL-related siblings, so some context about which parameter to use and when to prefer this tool would improve completeness.

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 context by pointing to a docs URL, which maps naturally to the url parameter, but it does not explain the role of the other eight optional parameters or confirm that 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 states a concrete operation — return the HTTP status for a public library docs URL — and clarifies that the body is discarded, which distinguishes it from content-fetching tools like web-fetch. It is not a tautology and names the resource and result type, though 'public library docs' is slightly ambiguous and no sibling name is given.

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 'Body discarded' implies the tool is appropriate when the agent needs only a status code and not page content, which is a usage signal. However, it does not explicitly name alternatives such as fetch-status, web-fetch, or browser-url-ok, nor does it state when not to use the tool.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It clearly discloses a non-obvious behavior: values are discarded, meaning the result depends only on key presence. It does not spell out the return type, but 'Count' strongly implies a numeric count and the operation is inherently read-only.

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

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

Two short sentences, no filler, and the key behavior ('Values discarded') is front-loaded immediately after the purpose. Every word earns its place.

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

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

The description is mostly sufficient for a simple counting tool, but it leaves some ambiguity about whether 'a JSON object' refers to the tool-call arguments object or a JSON payload to inspect, especially given the 'json' parameter. There is no output schema, and the description does not explicitly state the return value, though 'Count' implies it.

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

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

Schema coverage is 100%, so baseline is 3. The description adds important meaning by stating that values are discarded, which clarifies that the content of the string parameters does not matter beyond satisfying the schema. This prevents misusing the parameter descriptions as value-dependent instructions.

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 ('Count') and resource ('keys in a JSON object'), and the additional 'Values discarded' disambiguates it from related validation and shape-check tools. It clearly distinguishes from siblings like validate-json, which validates rather than counts.

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 implied by the description: use the tool when you need to count keys and ignore values. However, it does not explicitly state when to prefer it over alternatives or call out exclusions, so the guidance is implicit rather than explicit.

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

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

With no annotations, the description carries the behavioral disclosure burden. It clearly discloses the core behavior: returns origin, host, and path, and drops query and fragment. However, it does not mention error behavior, whether the URL is fetched or only parsed, or how the many unrelated schema parameters are treated, so transparency is partial.

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

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

The description is two short sentences with no filler. It front-loads the action and output, then adds the key transformation rule. Every clause earns its place.

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

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

Despite being concise, the description is incomplete for the tool's apparent complexity. It does not address the nine-parameter input schema, the lack of an output schema, or the absence of annotations. An agent cannot tell whether non-URL parameters are accepted, ignored, or used for some other purpose, which makes the overall tool context unclear.

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 already has a documented meaning. The description adds no parameter-level detail beyond the URL focus. With nine optional parameters including seemingly unrelated fields like city, feed, json, and zone, the description does not help an agent understand which parameters are relevant for this tool, but the schema itself carries that burden.

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

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

The description states a specific verb ('Return'), a clear resource ('a URL'), and the exact output components ('origin, host, and path'). It also clarifies the transformation applied ('Query and fragment are dropped.'), which makes the tool's job unambiguous and distinct from fetching or validation siblings.

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 the many URL-related sibling tools such as browser-url-ok, fetch-status, or domain-shape. It implies normalization use but provides no exclusions, prerequisites, 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?

Adds one behavioral detail beyond the annotations: 'No browser is launched.' This usefully sets expectations about cost and side effects. Still, it does not explain what 'can be opened' actually means (syntactic validation vs. HTTP request), and it omits whether inputs are discarded. With annotations already covering readOnly/idempotence, the description adds only modest behavioral clarity.

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

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

Two short, front-loaded sentences with zero padding. The core action and the key differentiating behavior ('No browser is launched') are both present, so it is efficient and to the point.

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 8 parameters and no output schema, a one-sentence description is inadequate. It does not explain the relationship between 'url' and the other schema fields (city, feed, json, path), does not describe the return value or response format, and leaves agents unsure how to interpret the result of the 'check.' This is a significant completeness 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?

The tool description itself does not mention parameters, but the input schema already provides descriptions for all parameters with high coverage, so the baseline is met. The description adds no extra meaning about parameter purposes or relationships; in fact, it emphasizes only 'url,' which could mislead given the schema's diverse 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?

States a clear action and resource: 'Check whether a URL can be opened.' The qualifier 'No browser is launched' helps distinguish it from heavier browser-based alternatives like browser-url-ok. However, the schema contains many unrelated parameters (city, feed, json, path), which muddies the actual scope and prevents a perfect 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 when-to-use guidance is provided. It does not mention when to choose this tool over siblings like browser-url-ok, web-fetch, or fetch-status, nor any exclusions or prerequisite conditions. The agent is left to infer usage entirely.

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 the only behavioral statement ('Query discarded') largely repeats the query parameter's schema description. It does not disclose that the other eight parameters are likely ignored, whether the query parameter is required, or what the return value looks like.

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. Every word contributes to the core message: count the query's characters and discard the query.

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 string parameters and no output schema, a one-line description is insufficient. It does not state whether the character count is the only output, what happens when no query is provided, or why the other parameters are accepted, leaving an agent to guess how to invoke it correctly.

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

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

Schema coverage is 100%, so the baseline is 3 because the schema already documents all parameters. The description adds minor clarification that the count is in characters, but it does not explain which parameter is the search query or how the unrelated parameters should be handled.

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 object: 'Count characters in a search query.' It clearly identifies the core function and avoids tautology. It does not explicitly differentiate from sibling length-related tools like memory-key-count, so it falls 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?

There is no guidance about when to use this tool versus alternatives, no preconditions, and no exclusions. The description only says what the tool does, not when an agent should select it.

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

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

There are no annotations, so the description carries the full behavioral disclosure burden. It only labels the tool as a catalog and does not explain whether it returns a complete list, filters by an input, performs validation, or has any side effects.

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

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

The description is short, but the single sentence is under-specified rather than effectively concise. It mostly restates the tool name, and the word 'Short' adds no operational value for an 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 nine optional parameters, no output schema, no annotations, and 27 sibling tools, this description is far too thin. The agent cannot determine which of the unrelated parameters—url, city, json, path, zone, query, etc.—matter or what the response will look like.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description itself adds no parameter-level meaning, but each parameter already has a descriptive comment in the schema, so the description does not need to compensate.

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

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

The description is a noun phrase that mostly restates the tool name: 'status-catalog' becomes 'catalog of common HTTP status codes.' It does not state a clear action and gives no indication of how the nine optional parameters are meant to be used.

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 siblings such as fetch-status or normalize-url. With no required parameters and nine optional ones, an agent has no clue what input, if any, should be supplied to retrieve the catalog.

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

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

The ReadOnly annotation already covers the safety profile, so the description's added value is 'Prompt discarded' plus the schema's repeated 'discarded after' notes, which together disclose that this is a stateless, input-ignoring function that returns the same fixed template. That is genuinely useful context, but the description remains silent on output format, edge cases, and what a caller should expect to do with the result. No contradiction with annotations, though the prompt-enhancement annotations sit uneasily beside 'Prompt discarded'.

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

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

Two short sentences with zero filler; the primary action is front-loaded. The second sentence 'Prompt discarded' is cryptic but deliberate and earns its place as a behavioral disclaimer. It is efficient to the point of under-specification, which is the only reason it is not a 5.

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

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

For a tool an agent must decide to invoke, the description does not explain the template's purpose, content, or what value it provides, and there is no output schema to fill that gap. The agent cannot anticipate what 'three-step thinking template' will look like or why it would help. This is thin for a tool nested among many purpose-named 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?

All 7 parameters have rich descriptions in the schema (ref, url, city, feed, host, json, path), so baseline is 3. The prose description adds no parameter meaning beyond the schema, and it introduces the word 'prompt' which matches no schema property — a minor source of ambiguity. There is no compensation needed since schema coverage is 100%.

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?

'Return a three-step thinking template' states a specific verb, resource, and scope — the agent knows it will receive a small, fixed reasoning template. 'Prompt discarded' adds a distinguishing behavior, signaling this tool does not process its inputs the way siblings like validate-json or normalize-url do. It loses the 5 because it never says what the template is for or what a 'three-step thinking template' actually contains.

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

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

There is no when-to-use guidance, no exclusions, and no named alternative. The 'desc contains say-when' annotation appears unsupported — 'Prompt discarded' describes behavior, not a condition for choosing this tool. An agent comparing against sibling tools like web-fetch or validate-json receives no basis for selecting think-steps.

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. It states the basic read behavior but does not disclose the output format, behavior for invalid or missing timezone names, or whether the call is side-effect-free beyond what is obvious. No contradiction exists, but the disclosure is thin.

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

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

A single sentence with no filler; the core behavior is front-loaded. Every word earns its place.

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

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

The tool has many optional parameters and no output schema, but the description does not specify return format, confirm that zone is the operative parameter, or explain the significance of the discarded fields. Relying on schema descriptions alone leaves meaningful ambiguity for an agent invoking the tool.

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

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

Schema description coverage is 100%, so the baseline is 3; the schema already documents each parameter, including zone. The description adds little beyond the phrase 'named IANA timezone' and does not clarify which of the many parameters to populate or that zone is effectively required.

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: returns the current time for a named IANA timezone. It distinguishes the tool from generic time lookups, but it does not explicitly call out siblings like utc-time or iana-zones, so it misses the top sibling-differentiation mark.

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

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

The description implies the use case: use this when an IANA timezone name is available and current local time is needed. There is no explicit when-not-to-use guidance or comparison with alternative tools such as utc-time or iana-zones, so it's only implicitly useful.

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. 'Current UTC timestamp' implies a read-only, side-effect-free call that returns a time value, but it does not clarify that all schema parameters are irrelevant or discarded, nor does it specify the timestamp format.

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 three words and contains no filler; the key information is front-loaded. For a trivial zero-required-parameter tool, this is appropriately concise.

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

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

The description does not explain that the nine optional schema parameters can be ignored, and it leaves the output format unspecified. Given the unusually broad schema, an agent could reasonably wonder if one of those parameters changes the behavior.

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

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

Because schema description coverage is 100%, the baseline is 3 even though the tool description adds no parameter-level meaning. The schema already documents every parameter, with several explicitly marked as discarded.

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

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

The phrase 'Current UTC timestamp' clearly communicates that the tool returns the current UTC time, even though it is a noun phrase rather than an explicit action. It does not distinguish this from sibling time tools like timezone or iana-zones beyond the UTC qualifier.

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 the other time-related siblings, and no note that it requires no meaningful arguments. It is not misleading, but it leaves the selection decision entirely to inference.

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

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

With no annotations present, the description carries the full burden, but it only discloses that the body is discarded. It does not explain what validity means, what the tool returns, whether side effects occur, or that all other schema fields are seemingly 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 compact and front-loaded with the core purpose. The second sentence adds a small but relevant behavioral note, though it is also somewhat sparse.

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 eight parameters, no annotations, and no output schema, the description is under-specified. It never identifies which parameter is the 'body', what output to expect, or how the unrelated schema fields relate to the tool.

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

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

The description itself adds no parameter meaning, but the input schema provides descriptions for every parameter, so schema coverage is high. The baseline of 3 applies because the description does not need to duplicate schema information.

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

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

The description clearly states the tool's function: check whether a body is valid JSON. However, it does not explicitly differentiate from sibling shape-check tools, and the term 'body' is ambiguous given the schema contains a dedicated `json` parameter and several unrelated-looking fields.

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 over alternatives such as file-path-ok or domain-shape. No conditions, exclusions, or examples are provided.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It names Open-Meteo, which implies an external network call, but it does not state that the call is read-only, which parameters are actually used, what happens when extra parameters are supplied, or what the response looks like. The schema's 'discarded' notes are 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 a single sentence with no filler: 'Current temperature for a city via Open-Meteo.' It is front-loaded with the tool's purpose and immediately communicates the essential domain.

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 is a 9-parameter tool with no output schema and no annotations, so the description needs to supply more context. It fails to state that only 'city' should generally be supplied, what temperature units are returned, or what happens for invalid or unknown cities. The presence of many unrelated optional parameters makes the missing guidance more damaging.

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 some value by highlighting 'city' as the key input, but it does not clarify the role of the other eight optional parameters. The schema descriptions for those parameters say they are 'discarded' after checks, which is ambiguous for an agent deciding how to call this tool.

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

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

The description clearly identifies the tool as returning current temperature for a city via Open-Meteo. It names the resource (city), the data (current temperature), and the source. It does not use an explicit verb like 'gets', and it does not actively distinguish itself from siblings, but the weather focus makes the purpose clear.

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

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

The description implies when to use the tool: when a current city temperature is needed. However, it gives no explicit guidance about which parameters are meaningful, especially because the schema has eight other optional parameters that appear irrelevant. It also does not mention alternatives or exclusions.

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

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

Because no annotations are provided, the description carries the full disclosure burden. It usefully discloses that the response body is discarded and that only HTTP status/content type are relevant, which is genuinely valuable behavioral information. Still, it omits network behavior such as redirects, timeouts, HTTP method, auth expectations, and error/response shape, leaving meaningful gaps for a network-fetching tool.

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

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

The description is two short sentences with zero filler: the first states the purpose and the second adds a critical behavioral caveat. It is front-loaded, scannable, and every word contributes to the agent's understanding.

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 full schema coverage, the tool has 9 optional parameters, no annotations, no output schema, and numerous sibling tools. A two-sentence description leaves too much implicit, especially how the non-URL parameters relate to the tool, what exact response/error contract to expect, and when to prefer this over similar fetch/status siblings. The return values are partially stated, so it is not completely inadequate, but it is under-specified for the tool'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?

Schema description coverage is 100%, so the description does not need to re-document parameters; baseline is 3. The phrase 'a public URL' maps naturally to the `url` parameter, but the description adds no guidance about the other eight optional parameters or whether they are actually used or ignored. The schema descriptions themselves compensate for most of that 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 clearly states the operation's core output—HTTP status and content type—and scopes it to public URLs, with the explicit 'Body discarded' caveat distinguishing it from content-returning fetch tools. It lacks an explicit verb like 'returns' or 'fetches', and the name overlaps with the sibling 'fetch-status', but the resource and scope are reasonably clear.

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

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

The 'public URL' qualifier and 'Body discarded' line imply the tool is for reachability/type checks rather than content retrieval, which gives some contextual guidance. However, there is no explicit when-to-use/when-not-to-use statement, no mention of alternatives among the 27 sibling tools, and no exclusion criteria beyond 'public' and 'body discarded'.

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 must carry full behavioral burden. It discloses only 'Title discarded after the call,' which is a minor statelessness hint, but it does not say whether the tool makes a network request, what side effects it has, or what failure modes 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?

Two short sentences with no superfluous content. The primary purpose is front-loaded, and the second sentence adds useful behavioral context about the input being discarded.

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

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

The tool is simple but the description omits the essential link between purpose and input schema, the return value, and the operational behavior. With no annotations and no output schema, this is insufficient 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?

The input schema lists seven generic parameters (ref, url, city, feed, host, json, path), none of which is identified as a Wikipedia title. The description never maps 'Wikipedia title' to any parameter, so an agent cannot determine how to construct a valid call. This is a critical gap in 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 uses the specific verb 'Check' and the resource 'Wikipedia title', so the tool's core purpose is clear and distinct from sibling validation tools. However, it does not explain how the title is supplied, and the input schema contains no 'title' parameter, making the stated purpose ambiguous in practice.

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 any sibling tool. It does not identify alternatives, prerequisites, or typical invocation contexts, leaving the agent to infer usage from the name alone.

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