ISO country MF

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

With no annotations, the description carries the transparency burden. It does disclose an important behavioral trait ('Task text discarded') and the return artifacts, but it does not explicitly state read-only behavior, external calls, or cost/authentication implications. It is adequate for a lookup but not rich.

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

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

Two sentences, front-loaded with the purpose, and each phrase earns its place: what it finds, what it returns, and the key caveat that task text is discarded. 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 description covers purpose and return values, which matters because there is no output schema. However, with nine optional parameters and no annotations, it never explains how (or whether) the parameters relate to 'finding' the Monid gateway, so an agent is left uncertain about invocation details.

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

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

Schema description coverage is 100%, so the structured schema already documents each of the nine optional parameters and notes that values are discarded after checks. The description adds no per-parameter meaning, so it stays at the baseline.

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

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

The description opens with a specific verb and resource—'Find a public pay-per-call tool gateway (Monid)'—and enumerates the concrete returned artifacts (CLI setup, how-it-works, skill file, remote MCP hops). This makes it easy to distinguish from the sibling utilities.

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

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

The intended use ('when you need Monid gateway documentation') is implied by the verb 'Find,' but the description gives no explicit when-to-use vs. when-not-to-use guidance or alternatives among the sibling tools. A caller must infer that this is the right registry/lookup tool.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. It only reveals that no browser is launched; it does not say whether a network request is made, whether it returns a boolean, or whether non-URL parameters are discarded. The schema's 'discarded after the shape check' hints are not reflected in the description.

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

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

Two short, front-loaded sentences with no redundancy. However, brevity comes at the cost of critical information, so it is not a perfect 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?

Given 9 parameters, no annotations, and no output schema, an agent cannot tell what to pass, what result to expect, or whether the check is offline vs network-based. The definition is too sparse 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 each parameter has a description; baseline 3 applies. The tool description adds nothing about how to fill parameters, and the 'url' parameter's schema text ('normalize or cite') conflicts in spirit with the tool's 'check whether a URL can be opened', so the description fails to reinforce which parameter is the target.

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 action ('Check whether a URL can be opened') and a target resource (URL), and the second sentence distinguishes it from browser-launching tools like playwright-url-ok. However, it leaves unstated whether this is a syntax check, DNS check, or HTTP reachability check, and it does not clarify the relationship to the many other parameters.

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

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

No guidance on when to choose browser-url-ok over siblings like fetch-status, normalize-url, or playwright-url-ok. The only implicit hint is 'No browser is launched', which excludes browser automation but does not state the appropriate use case 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 must carry behavioral disclosure. It mentions only that an expression is discarded; it does not state what is returned, whether calls are side-effect free, how the schema fields are used, or any error/limit 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 definition is short and front-loaded, but the second sentence is cryptic and the whole description is under-sized relative to a nine-parameter schema. This is under-specification rather than disciplined conciseness.

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 parameters, no annotations, no output schema, and no return-value specification, the description is functionally incomplete. An agent cannot determine what to pass, what the result contains, or whether this is even the correct tool for arithmetic evaluation.

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 a baseline of 3 applies. The tool description adds no parameter-level meaning and mentions an 'expression' that is not in the schema, but the schema's own descriptions already document each property.

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 operation ('evaluate a+b style arithmetic'), so it is not a tautology, but it never connects that operation to any of the nine input properties. 'Expression discarded' adds confusion rather than clarifying what input carries the expression.

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

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

There is no when-to-use or when-not-to-use guidance and no reference to any sibling tool or alternative. The only implied context is arithmetic evaluation, which cannot be reliably acted on because the schema exposes no expression parameter.

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 for behavioral disclosure, and it does add one meaningful promise: 'Page content is not stored.' However, it does not state whether a network request is made, whether redirects are followed, or what happens on HTTP errors, so the behavioral picture remains 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 with the operative outcome front-loaded and the privacy guarantee stated immediately after. Every word earns its place.

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

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

For a tool whose schema exposes seven distinct string inputs—ref, url, city, feed, host, json, and path—covering only URL behavior is incomplete. Without an output schema, the description also omits return-structure guidance for the host/scheme/HTTP-status result.

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

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

Schema description coverage is high and every parameter already has its own explanatory description, so the baseline applies. The top-level description adds primary-URL framing, but it does not clarify ambiguous fields such as path, whose schema description duplicates host, or explain how the non-URL fields fit together.

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

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

The description states a specific action and result: return host, scheme, and HTTP status for a URL. It is not a tautology, though it does not explicitly distinguish this tool from siblings like fetch-status or normalize-url, nor does it acknowledge the other input fields in the schema.

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

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

There is no explicit guidance about when to use this tool versus related siblings such as fetch-status, normalize-url, or web-fetch. The phrasing implies URL metadata use, but with many overlapping sibling tools, the absence of exclusions or alternative routing leaves the agent without sufficient direction.

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 does add a useful privacy trait ('No identifiers are retained') and the schema reinforces that several parameters are discarded. However, it does not disclose whether the tool makes external calls, has side effects, or how the classification is computed.

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

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

The description is compact and front-loads the core action, with a separate sentence for the privacy guarantee. There is no filler or redundancy, though the brevity contributes to the lack 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?

For a tool with 9 optional parameters, no required fields, no output schema, and no annotations, this description is severely under-specified. An agent does not know what classifications are possible, what return value to expect, or which combination of parameters to supply.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself adds no parameter-level meaning, but the schema already provides detailed semantics for each field, including which values are 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 description states a verb and object ('Show how this request is classified'), but it never explains what a classification is, what categories exist, or what inputs trigger the classification. It is understandable at a high level but too vague to distinguish from sibling shape/hint 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 instead of siblings like validate-json, domain-shape, or normalize-url. No context is given for choosing compatibility over alternatives, and no exclusion criteria are mentioned.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It discloses only that the tool avoids WHOIS or ownership data; it does not mention validation rules, IDN/punycode handling, return format, or whether any network access occurs.

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

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

A single front-loaded sentence communicates the core action and a key limitation with no filler or repetition.

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

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

There is no output schema and the description does not specify the return value or identify which of the nine optional inputs to use. The broad optional schema makes the tool ambiguous for an agent despite the clear one-line purpose.

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?

Input schema coverage is 100%, so the baseline is 3. The description's 'hostname' maps to the host property, but with nine optional parameters it does not clarify that only host is relevant for 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 uses a specific verb and resource: 'Split a hostname into labels'. The negative clause 'without WHOIS or ownership data' clearly separates it from lookup tools and sibling shape tools such as github-repo-shape.

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

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

The description implies usage for hostname label splitting and rules out WHOIS/ownership lookups, but it does not explicitly name sibling alternatives or state when a different tool should be used instead.

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 transparency burden. It does disclose the HTTP method (HEAD) and the return scope ('status only'), which strongly implies a read-only, non-destructive operation. However, it does not mention redirect behavior, authentication needs, network side effects, or how the eight non-URL parameters are silently discarded.

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

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

The description is a single, front-loaded sentence with no filler: 'HEAD a public URL and return status only.' It is concise and easy to parse. However, given the nine-parameter schema and the large sibling list, the brevity borders on under-specification rather than appropriately sized 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?

The tool has nine optional parameters, no annotations, no output schema, and several similar URL-related sibling tools, yet the description only covers the URL case. It omits how to select among the other parameters, what the 'status' response looks like, and how this tool differs from sibling URL checkers. This is not enough context for reliable selection and invocation.

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

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

Schema description coverage is 100%, so the structured descriptions already define each parameter. The main description adds limited semantic value by clarifying that the url parameter is used with a HEAD request, but it does not help an agent understand the roles of ref, city, feed, host, json, path, zone, or query relative to the tool's purpose. This meets the baseline but does not compensate for the broader 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 action ('HEAD a public URL') and a clear output ('return status only'), so the basic purpose is understandable. However, the input schema exposes eight other optional parameters (ref, city, feed, host, json, path, zone, query) that are described as 'discarded after the check', which the main description never accounts for. This makes the tool's actual scope ambiguous and potentially misleading for an agent deciding what it can do.

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 sibling tools such as browser-url-ok, playwright-url-ok, normalize-url, or web-fetch. It also does not explain which of the nine optional parameters should be supplied or whether exactly one is expected. No when-to-use or when-not-to-use conditions are stated.

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

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

No annotations are provided, so the description carries full behavioral disclosure burden. It reveals that this is a parse operation and that something is discarded, but it does not state what the tool returns, whether it performs validation, how failures are signaled, or whether any side effects exist. This is insufficient for an unannotated tool.

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

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

The description is very short and front-loaded with its main purpose, which is good. However, 'Path discarded' is cryptic and structurally abrupt, leaving the agent to guess its meaning. It is concise but 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 no annotations, no output schema, and a broad nine-parameter input schema. The description does not clarify which parameter carries the Figma URL, what constitutes a valid Figma URL, or what the parse result looks like. This makes it incomplete for reliable invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter mapping benefit: the schema's 'url' description is generic ('HTTPS URL to normalize or cite') rather than Figma-specific, and 'Path discarded' merely echoes the schema's note that path is discarded after the check. The agent still has to infer which of the nine fields is the Figma URL.

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

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

The description clearly states a specific action and resource: 'Parse a Figma file URL.' This distinguishes it from generic URL tools, though it does not explicitly differentiate from sibling shape-check tools. The second sentence 'Path discarded' is ambiguous—it could mean the URL's path or the schema's path parameter.

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

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

The tool name and description imply it should be used for Figma URL parsing, which provides contextual selection guidance. However, there is no explicit when-to-use or when-not-to-use instruction, and no alternatives such as browser-url-ok or github-repo-shape are mentioned.

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

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

With no annotations, the description carries the full behavioral burden. 'No disk access' is a meaningful disclosure that this is a purely syntactic check with no filesystem side effects, but it does not explain what 'safe' means, whether it returns a boolean, or how invalid inputs are handled.

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

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

The description is two short sentences with no filler. The core purpose is front-loaded and 'No disk access' is a valuable non-obvious addition that 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 its apparent simplicity, this tool has 9 optional parameters, no required fields, no output schema, and no annotations. The description gives no indication of which parameter to use, what the response looks like, or why so many unrelated parameters appear in the schema, making the definition inadequate for reliable invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself adds no parameter-level detail, and worse, the schema exposes eight other entirely unrelated optional parameters (url, city, feed, host, json, zone, query) with no hint that only 'path' is relevant for this tool.

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

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

The description states a clear action ('Check') and resource ('a path'), and the title reinforces the file-path focus, which helps distinguish it from URL- and domain-checking siblings. However, 'looks safe' is vague and does not define what safety criteria are applied.

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

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

No guidance is given about when to use this tool versus alternatives like browser-url-ok or domain-shape. The 'No disk access' note is a useful hint but does not state exclusions or selection conditions.

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

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

With no annotations, the description carries the full behavioral burden, but it only mentions the external data source and output. It does not disclose that most parameters are discarded after validation, that this may involve a remote API call, or what happens on invalid 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 a single front-loaded sentence with no filler or repetition. It is economical and easy to parse, though it is under-specified in ways better captured by 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?

Given 9 optional parameters, no output schema, and no annotations, the description is too thin for reliable invocation. It does not say which parameter supplies the place, whether only one parameter should be passed, or that most fields are validation-only, leaving an 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?

Schema description coverage is 100%, so the baseline applies; every parameter already has a description. The tool description adds the idea that a 'place' is involved but does not map that to any specific parameter, such as city or query, so it adds little semantic value.

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

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

The description clearly states the tool's output—latitude and longitude for a place—and names Open-Meteo as the data source. It is distinguishable from sibling tools like weather-hint or timezone, though it lacks an explicit verb such as 'geocode' or 'look up'.

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 provides no guidance on when to use this tool versus alternatives, no exclusions, and no indication of which input parameter identifies the 'place.' Usage is only weakly implied: when you need coordinates for a place.

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

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

With no annotations, the description carries the full behavioral burden, yet it only states the core parse operation. It does not disclose return format, read-only status, behavior on non-GitHub URLs, or what the other eight parameters do. The schema's repeated 'discarded after the shape check' notes even imply a shape-validation behavior that conflicts with the extraction behavior the description suggests.

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 free of filler and efficiently worded, earning credit for conciseness. But at nine words it is under-sized for a tool with nine parameters, 26 siblings, and no annotations or output schema to supplement it.

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

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

For a high-complexity tool with 9 optional parameters, no output schema, and no annotations, a one-sentence description is inadequate. An agent cannot determine what the tool returns, which parameter carries the GitHub URL, or how malformed URLs are handled. The definition needs substantial expansion to support 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 schema coverage is 100%, the description never maps the GitHub-URL purpose to any of the nine parameters — the agent cannot tell whether to populate url or one of the other eight. The schema's url description ('HTTPS URL to normalize or cite') actually conflicts with the description's 'GitHub URL' phrasing, and parameters like city and json appear entirely irrelevant to GitHub parsing.

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

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

The description uses a specific verb ('Parse') and resource ('owner and repo from a GitHub URL'), which clearly separates this from sibling shape tools like figma-url-shape and jira-key-shape. However, the generic 9-parameter schema (city, feed, json, query, zone) casts doubt on whether the tool truly specializes in GitHub URLs, so it does not fully earn 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 on when to use this tool versus normalize-url, domain-shape, or fetch-status — siblings that all accept URLs. With 26 sibling tools and several overlapping URL-handling capabilities, the agent must infer selection criteria entirely from the name. There is also no statement about when not to use it.

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

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

No annotations are provided, so the description carries the full burden of explaining behavior. It does disclose one behavioral trait, 'Titles discarded,' but omits other important behaviors such as whether the tool makes a network request, whether it is read-only, how fresh the count is, and how the 9 parameters are handled. The schema mentions many parameters being 'discarded,' but the description itself does not clarify that all parameters are effectively ignored.

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

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

The description is very concise: two short sentences, with the main action front-loaded. There is no fluff or redundant wording. However, it is arguably too terse given the tool's confusing 9-parameter schema and lack of output schema, so it earns high marks for conciseness but not perfection.

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 incomplete. It does not say what the return value looks like, whether parameters are needed, which parameters are relevant if any, or what side effects might occur. The core purpose is clear, but the invocation contract is almost entirely absent, leaving an agent unable to call the tool confidently.

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

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

Although the schema has 100% description coverage, the description adds no parameter semantics and creates a notable mismatch: the tool counts Hacker News front-page stories, yet the parameters include city, json, path, zone, and query. The schema descriptions say things like 'discarded after the shape check' or 'discarded after the call,' but the description never explains whether any parameter should be supplied or whether all are optional and ignored. An agent cannot determine what to pass from the description alone.

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

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

The description states a specific action and resource: 'Count current Hacker News front-page stories.' This clearly identifies the tool's core purpose and distinguishes it from generic fetch or search tools. The phrase 'Titles discarded' adds useful scope by indicating that only a count is returned, not the story titles.

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 alternatives, nor does it mention any exclusions or prerequisites. With dozens of sibling tools like web-fetch, normalize-url, and validate-json, the agent gets no help choosing this tool over them. There is no 'when not to use' or reference to a more appropriate 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It conveys that the tool provides timezone names (an implicit read-only list), but it does not state return shape, side effects, or behavior when called with the various optional parameters. It does not contradict 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?

A single short sentence with no filler, and the key content ('IANA timezone names' and 'clock calls') is front-loaded. It is concise, though it borders on under-specification.

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 or annotations, yet the description gives no invocation context, no indication of which parameters apply, and no return details. The loose connection between the description and the parameter set leaves an agent under-informed.

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 every parameter has a schema description and the baseline is 3. The tool description adds no semantics about how the parameters relate to the timezone names, but the schema itself covers 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 identifies the resource ('common IANA timezone names') and the intended domain ('clock calls'), which is more than a tautology but lacks a specific verb or operation. It does not differentiate this from sibling clock/time tools 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?

'For clock calls' implies a usage context, but there is no explicit when-to-use guidance, no exclusions, and no mention of alternatives. Sibling tools like timezone and utc-time are not referenced.

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 disclosure burden, but it only reveals that the output is group counts. It does not disclose error behavior, whether the fetch is read-only, which URL or host is used, or what happens when robots.txt is missing; the 'discarded after' parameter descriptions add confusion.

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; the main outcome is stated immediately. It is as concise as it can be, though this comes at the cost of usage and parameter guidance, which are penalized separately.

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

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

For a 9-parameter tool with no output schema and no annotations, one sentence is insufficient: it does not specify the return shape of 'group counts', the required parameter, failure behavior, or how this differs from sibling fetch tools. It conveys only the core outcome.

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 descriptions do not connect any parameter to the robots.txt fetch: `url` is described as 'normalize or cite', not as the robots.txt source, and multiple params are explicitly discarded. The description adds no cross-reference, so an agent cannot tell which parameter actually drives the operation.

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

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

States a clear action ('Fetch a public robots.txt') and a constrained result ('return group counts only'), so an agent knows the operation. However it does not name the sibling it is distinct from or specify which parameter supplies the robots.txt URL, and several schema parameters (city, feed, json, path) seem unrelated to the stated 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 when-to-use or when-not-to-use context is provided, and no alternatives are named despite close siblings like web-fetch, fetch-status, and normalize-url. The only implied usage is that callers wanting only group counts rather than raw contents would use it, but this is not 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?

There are no annotations, so the description bears the full burden of behavioral disclosure. It only adds 'Key discarded,' which is vague and doesn't explain the output, error behavior, or how the shape check is performed. This is insufficient for an agent to predict the tool's behavior.

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

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

The description is very short, and the core action is front-loaded in the first sentence. The second sentence, 'Key discarded,' is terse and earns its place only partially, but there is no fluff or redundant 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?

Given no annotations, no output schema, and a seven-parameter schema with no obvious way to supply a 'Jira key,' the description is far from complete. It leaves crucial invocation details unresolved and provides no information about valid output or failure modes.

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 documents all seven parameters, so the baseline is 3, but the description adds no parameter-level context and even creates a mismatch by referring to a 'key' that is not present in the input schema. The agent cannot map the described purpose to any of the provided 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 states a specific action ('Check a Jira issue key shape') and clearly identifies the resource as a Jira issue key, distinguishing it from sibling shape-checking tools. However, the meaning of 'Key discarded' is ambiguous and no input parameter named 'key' exists in the schema, which slightly undermines the clarity.

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

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

The phrasing implies the tool should be used when one needs to check whether a value has the shape of a Jira issue key. It does not provide explicit when-to-use or when-not-to-use guidance, nor does it mention sibling alternatives like github-repo-shape 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 must carry behavioral disclosure; it does add the meaningful fact that the body is discarded and only the HTTP status is returned. It remains incomplete for a nine-parameter tool, saying nothing about redirects, timeouts, or the fact that non-URL parameters appear to trigger entirely different checks.

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

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

The text is compact and front-loaded, with no filler. But given the nine-parameter surface, it is under-specified rather than efficiently complete, covering only one use case in a way that is concise but not appropriately sized.

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

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

There is no output schema and no annotations, yet the description does not explain what a successful response looks like beyond 'HTTP status', which parameter to provide for which mode, or how the multi-purpose parameters interact. An agent cannot confidently invoke this tool correctly from the description alone.

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

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

Schema description coverage is 100%, so the schema already documents each parameter and the description does not need to restate them. The description only reinforces the url use case and does not add semantics for the other eight parameters, which is acceptable because the schema 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 names a concrete operation ('HTTP status for a public library docs URL') and notes the body is discarded, so the basic action is identifiable. However, the input schema exposes nine unrelated optional parameters (city, feed, json, path, timezone, query), making the stated scope much narrower than the actual tool surface and leaving the core purpose ambiguous.

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 prefer this tool over sibling URL/status tools such as fetch-status, browser-url-ok, normalize-url, or web-fetch, and no exclusions or alternative routing. The only implicit cue is the 'public library docs' phrase, which is insufficient for reliable selection.

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 supplied, the description carries the behavioral burden. It does disclose that values are discarded, which is a useful trait, but it does not explain count semantics (top-level vs nested keys), invalid JSON behavior, or the return value, leaving meaningful ambiguity for an agent.

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

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

The description is extremely concise: two short sentences with no filler. The core action is front-loaded, and 'Values discarded' earns its place by clarifying the tool's scope.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, a single-sentence description is insufficient. The agent is left to guess how to supply the JSON object, whether nested keys are counted, and what happens with invalid JSON, so the definition is not complete enough for reliable invocation.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds the concept of counting keys and discarding values, but it never connects this to the `json` parameter; several schema descriptions mention discarding inputs, which makes parameter selection less obvious rather than more 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 clear action ('Count keys') on a specific resource ('a JSON object') and adds 'Values discarded' to signal that only structure matters, which helps distinguish it from validation/shape tools like validate-json. It is not fully unambiguous, though, because it never says which parameter supplies the JSON object or whether the count is top-level 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?

No when-to-use guidance or comparison to alternatives is provided. 'Values discarded' hints that the tool is useful when values are unimportant, but there is no explicit condition, prerequisite, or routing away from sibling tools with related purposes.

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

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

No annotations are present, so the description carries the burden. It transparently states the output fields and that query/fragment are discarded, giving an agent a clear expectation of return shape. It does not mention error handling, validation, or whether non-url parameters have any effect, leaving some 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 a single concise sentence with no filler. It front-loads the primary result and adds the caveat about query/fragment without redundancy.

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

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

Given the tool has 9 parameters, none required, and no output schema, the description is too terse to fully disambiguate which parameter drives normalization (e.g., 'url' vs 'feed'). It also omits any mention of parameter precedence or what happens when multiple parameters are supplied, so an agent may not invoke it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level details beyond implying the 'url' parameter is the primary input, which is already clear from the schema. No bonus.

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

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

The description uses a specific verb ('Return') and resource ('URL'), and clearly names the output components (origin, host, path). The behavior of dropping query and fragment further distinguishes it from URL look-up or fetch tools, though it doesn't name sibling alternatives explicitly.

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 statement 'Query and fragment are dropped' gives an implicit when-not-to-use: if the caller needs query/fragment, this tool is unsuitable. However, no explicit alternative or selection condition is provided, and the 9 sibling tools are not referenced, so guidance is weak.

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

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

Since no annotations are provided, the description carries the behavioral disclosure burden. It does disclose one meaningful behavior: no browser is launched. However, it does not state whether the URL is actually fetched over the network, what side effects might occur, or what the success/failure response 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 remarkably concise: two short sentences, no filler, and the most important behavioral constraint ('No browser is launched') is clearly stated. 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 having 9 optional parameters and no output schema, the description does not explain how the parameters relate to the URL check, which parameter should be provided, or what the tool returns. An agent would struggle to know how to invoke this tool confidently, especially with so many seemingly unrelated optional inputs.

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

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

The input schema has 100% description coverage, with each parameter receiving its own specific description. The tool description itself adds no parameter-level meaning, but the schema already documents the parameters, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's function with a specific verb and resource: 'Check whether a URL can be opened.' The additional phrase 'No browser is launched' helps differentiate it from browser-based alternatives like browser-url-ok, though it does not explicitly name any 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?

The phrase 'No browser is launched' implies the tool is appropriate when a browserless URL check is needed, but it does not explicitly state when to use this tool versus alternatives like browser-url-ok or fetch-status. Usage context is only implied, not directly explained.

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 disclose that the query is discarded, signaling a read-only, non-persistent operation. However, it says nothing about the return value, error behavior, or how multiple provided parameters are handled.

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

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

The description is short and front-loaded, with both sentences earning their place: the first states the function, the second clarifies the data-handling behavior. It is not padded with unnecessary detail. It could be slightly more informative without becoming bloated, but as written it is efficient.

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

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

Despite a 9-parameter schema and no output schema, the description only explains the query-counting behavior and does not clarify which parameter to populate, what the tool returns, or why the other parameters exist. An agent can parse the schema descriptions, but the tool description alone leaves important context missing for reliable invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds little beyond the schema: it mentions 'search query,' which aligns with the 'query' parameter description already present. The other eight parameters are not addressed in the description, but their individual schema descriptions compensate for that.

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 ('Count characters') and a resource ('a search query'), making the tool's core purpose clear. It largely restates the tool name, but adds the useful detail that the query is discarded. It does not explicitly differentiate from similarly named count tools like memory-key-count, though the resource is different.

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 on when to use this tool versus alternatives, and no mention of sibling tools or exclusions. The intended use is only implied by the phrasing 'Count characters in a search query,' which leaves an agent to infer when this tool is preferred over other length/count or shape-check tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Short catalog' implies a read-only reference, but it does not state the return format, whether parameters are required, or that many input parameters are effectively ignored despite the schema saying they are discarded.

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

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

The description is a single short sentence with no fluff, and the core subject is front-loaded. However, it is somewhat under-specified, which is the main reason it does not earn a 5.

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

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

Despite being a nominally simple reference tool, the input schema has eight parameters and no output schema, and the description does not explain how any of them relate to querying the catalog. An agent would be uncertain whether to pass arguments or expect a static list, making the definition incomplete for correct invocation.

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

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

The input schema provides descriptions for all parameters, so the schema coverage is high. The tool description itself adds no parameter-level meaning, but per the baseline for high schema coverage, a 3 is appropriate.

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

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

The description identifies the tool as a catalog of common HTTP status codes, which clearly conveys its subject matter and general function. It is distinguishable from siblings like fetch-status, which likely checks a live URL, though it does not use an explicit action verb like 'returns' or 'lists'.

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

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

There is no guidance on when to use this tool versus alternatives such as fetch-status or other URL-shape tools. The description only implies a reference use case but gives no explicit conditions, exclusions, 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 burden. It does disclose a meaningful behavioral trait: 'Prompt discarded,' indicating the tool ignores the input. However, it does not clarify whether all nine parameters are ignored, whether there are side effects, or what the template contains.

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

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

The description is only two short sentences with no filler. The core behavior is front-loaded and every word earns its place.

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

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

For a deterministic, no-input utility, the description is mostly sufficient: an agent can call it with no arguments and receive a template. Still, without an output schema or any detail about the template's structure, it is slightly under-specified.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning beyond saying the prompt is discarded; each parameter's discard behavior is 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 clearly states the action ('Return') and the resource ('a three-step thinking template'), and adds the notable behavior 'Prompt discarded.' However, it does not explicitly differentiate this tool from its many siblings; the tool name itself carries most of that distinction.

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

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

There is no guidance about when to use this tool versus alternatives. With 27 sibling tools, an agent receives no routing signal beyond the name and vague notion of returning a template.

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 burden of explaining behavior. It conveys the core read-only behavior of returning the current time, but it does not disclose output format, invalid-zone handling, or that most 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 eight words and front-loaded with the core action and object. Every word is functional, with no filler or repetition.

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 time lookup, the description plus the schema is minimally sufficient: the schema identifies the relevant zone parameter and describes the other parameters as discarded. However, the description alone does not clarify which parameter to use, and there is no differentiation from closely related sibling tools.

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

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

Schema coverage is 100%, so the baseline is 3. The description's 'IANA timezone' wording adds a small clarification, but the schema already describes the zone parameter as 'IANA timezone name to look up,' so the description adds little beyond the schema.

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

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

The description uses a specific verb and resource: 'Current time in a named IANA timezone.' It clearly states what the tool does, but it does not explicitly differentiate it from sibling tools like utc-time or iana-zones.

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

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

No guidance is provided about when to use this tool versus alternatives such as utc-time or iana-zones. The description only states the tool's function, leaving selection to inference.

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

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

With no annotations, the description must carry the behavioral burden. It states the output but does not disclose that the seven parameters are discarded, that no side effects occur, or what the exact return format is. The schema hints at discarding, 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 wasted words. It is appropriately concise for a simple tool, though it could have earned a 5 by briefly addressing the surprising parameter list.

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

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

The description is incomplete given the unusual schema: it never states that all arguments are optional and ignored, or that the tool can simply be called with no parameters. This missing context could easily confuse an agent into supplying one of the many listed but irrelevant 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?

The input schema documents all seven parameters with descriptions, including explicit 'discarded' notes, so the schema already provides solid coverage. The description adds no parameter meaning by not mentioning them at all, which keeps this 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 phrase 'Current UTC timestamp' clearly conveys what the tool returns and the UTC qualifier helps distinguish it from generic timezone tools. It lacks an explicit verb, but the meaning is unambiguous enough for an agent.

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

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

No guidance is provided on when to use this tool versus alternatives like timezone. The intended use is only implied, and there is no mention that all input parameters are effectively ignored.

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 only disclosed behavior is that the body is discarded, which adds a minor privacy guarantee. But it does not state what the tool returns (boolean? error?), whether it performs full syntax validation or schema validation, or how the many unrelated schema fields are treated. With no annotations to fall back on, this is insufficient.

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

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

One short sentence with no redundant words, and the core action is front-loaded. It could be improved by naming the parameter, but it is appropriately concise for such a simple 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 no output schema and no annotations, the description must explain the result and side effects. It only says the body is discarded, leaving the invocation contract and the role of the other seven parameters unexplained. This is a meaningful completeness gap for correct invocation.

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

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

The input schema already documents each parameter with descriptions, so schema coverage is complete. The description's 'body' is not directly tied to the `json` parameter, so it doesn't resolve which field to use. It neither clarifies nor harms, so a baseline 3 is appropriate.

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

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

The description states a specific action — checking whether a body is valid JSON — which clearly distinguishes it from sibling shape-checkers like `domain-shape` or `file-path-ok`. However, the term 'body' is ambiguous and not explicitly mapped to the `json` parameter, preventing 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?

Gives no guidance on when to prefer this tool over alternatives, nor any exclusions. The description doesn't mention that this tool is specifically for JSON syntax validation or that other shape-checkers exist, leaving an agent to infer its usage solely from the tool 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?

No annotations are provided, so the description carries the burden. It discloses that the tool uses Open-Meteo and returns current temperature for a city, which are useful behavioral hints. However, it does not state the output unit or format, error behavior, or the fact that non-city parameters are ignored, 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 a single, front-loaded sentence with no filler, which is good for conciseness. It sacrifices important behavioral and usage context, but structurally it is efficient.

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

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

For a tool with no annotations, no output schema, and a nine-property input schema, one sentence is incomplete. An agent cannot tell what value to expect, whether city is required, or how to treat the many unrelated parameters. The description is too thin to support correct invocation without extra guesswork.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself adds no parameter semantics, but the city parameter has a usable description. The presence of eight unrelated parameters in the schema is confusing, and none of them are marked required even though a city is semantically required for the stated purpose.

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

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

Description states a concrete resource (current temperature) and provider (Open-Meteo), and the schema makes city the obvious input. It is clear enough to distinguish from sibling tools like geo-hint or web-fetch, though it is phrased as a noun phrase rather than an explicit verb.

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

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

There is no guidance about when to prefer weather-hint over alternatives or when not to use it. The single sentence only describes the action, leaving the agent to infer that it should be used for current-temperature lookups. The description also does not warn that most schema properties are irrelevant to this weather 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 burden. It clearly discloses the key behavior: the response body is discarded, and only HTTP status and content type are returned. It also scopes the operation to public URLs, which meaningfully informs the agent about safety and scope.

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, information-dense sentences with no filler. The most important behavioral qualifier, 'Body discarded', is placed immediately after the primary purpose, making it easy to parse quickly.

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

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

This tool has nine optional parameters, no output schema, and no annotation safety net, yet the description does not explain which parameter drives the fetch or what the exact response shape is. The agent is left to infer how url, host, feed, path, and the other parameters relate to the described behavior, making the definition incomplete for confident invocation.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the tool description adds no parameter-specific meaning. The description's reference to 'a public URL' aligns with the url parameter, but it does not clarify how it relates to the other eight optional 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 clearly states what the tool returns for a public URL: HTTP status and content type, with the body discarded. This is specific enough to separate it from a generic page-fetch tool, though it does not explicitly distinguish it from similar siblings like fetch-status.

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

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

The phrase 'Body discarded' implies it should be used when only HTTP status and content type are needed, not when the body content is required. However, it provides no explicit guidance on when to choose this tool over sibling tools such as fetch-status, browser-url-ok, or normalize-url.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It mentions that the title is discarded, implying no persistence, but does not disclose the return value (e.g., a boolean), network usage, or side effects. The single behavioral note is insufficient for a safe read/check 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 only two sentences and gets to the point quickly. However, the second sentence about the title being discarded is ambiguous and arguably wastes a sentence by not explaining the input mapping.

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 a checker with no output schema, no annotations, and a complex seven-field input schema. The description fails to specify the output format, which parameter acts as the Wikipedia title, or how it differs from similar sibling tools, so an agent cannot reliably invoke 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 input schema lists seven parameters (ref, url, city, feed, host, json, path), none of which is described as the Wikipedia title. The description never maps the 'title' to any of these parameters, so an agent cannot determine what to pass. The schema descriptions cover each field's generic purpose but do not compensate for the missing connection to Wikipedia title.

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

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

The description states a specific verb and resource: it checks whether a Wikipedia title exists. This distinguishes it from sibling tools like file-path-ok or validate-json. However, the added 'Title discarded after the call' does not clarify which input parameter carries the title, slightly muddying the 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 gives no guidance on when to use this tool versus alternatives such as browser-url-ok or fetch-status. There is no statement of conditions, exclusions, or fallback tools, 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.