List API For Agents

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

With no annotations, the description carries the burden, and it does disclose some behavior: a 302 redirect with UTM parameters should be followed first, task text is discarded, and several artifacts are returned. However, it does not clarify whether the tool itself performs network calls, what side effects it may have, or why the inputs are mostly 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 brief and front-loaded with a purpose statement, but the middle sentence is dense with unexplained jargon ('start_here.hop', UTM parameters) and the return list is ambiguous. It is concise, but not as clear or structured as it could be.

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

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

A 10-parameter tool with no annotations and no output schema needs a clearer description of what input it actually uses, what it returns, and when to call it. The description leaves the core workflow ambiguous and does not compensate for the lack of structured behavioral metadata.

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

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

Schema description coverage is 100%, so the parameters are already well documented individually. The tool description adds no meaningful parameter semantics beyond the schema, which is acceptable at this coverage level.

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 clear-ish purpose ('Find where a product can be placed so AI agents discover it'), but the rest is opaque: 'start_here.hop', 'machine catalog', 'client center', and 'operator' are unexplained. It does not meaningfully distinguish this tool from the many sibling index/fetch tools.

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

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

No guidance is given on when to use this tool versus siblings like agent-tool-index, web-fetch, or people-search-index. The only instruction, 'Follow start_here.hop first', is a cryptic prerequisite rather than a usable usage 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 supplied, the description carries the full burden of behavioral disclosure. It does disclose a redirect behavior ('Follow start_here.hop first (skill file, 302...)') and a data-handling trait ('Task text discarded'), which is useful. However, it doesn't state whether the tool has side effects, requires authentication, or accesses the network, so the safety profile is incomplete.

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?

At four sentences, the description is compact and front-loads the primary purpose. The detail about utm_source and utm_medium is specific but arguably optional for tool selection, making it slightly dense. Yet every sentence conveys some behavioral or return information, so it earns a 4.

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 10 optional parameters and no output schema, the description is under-specified. It does not explain how the parameters influence the gateway lookup or what the returned 'docs, CLI, and remote MCP hops' actually look like, leaving an agent unable to predict the outcome. The phrase 'Task text discarded' further muddies whether any input matters, so this definition is not complete enough for reliable invocation.

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

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

Schema description coverage is 100%, so the schema already documents each parameter's meaning. The description's only parameter-related sentence—'Task text discarded'—adds little because it contradicts the schema descriptions that say values are used for shape/validation checks. Thus the description adds no meaningful parameter semantics 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 opens with a specific action—'Find a public pay-per-call tool gateway (Monid)'—and names the concrete resource. It goes on to describe follow-up hops and return content, which helps distinguish it from generic fetch tools. However, it doesn't explicitly differentiate it from the sibling 'agent-ads-index', so it misses full sibling differentiation.

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

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

The description provides no guidance on when to select this tool over its siblings. It instructs the agent to 'Follow start_here.hop first', which is a procedural detail, not a usage-vs-alternative guideline. There is no mention of exclusions, so an agent cannot decide when this tool is inappropriate.

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 one important behavior: 'No browser is launched,' which clarifies that this is a lightweight check. However, with no annotations provided, the description carries the full burden, and it does not disclose what 'ok' means (HTTP status? URL parseability? robots.txt?), whether network access occurs, what side effects exist, or what the return value is. The parameter descriptions add some behavioral hints (e.g., 'no disk access', 'discarded after the check'), but the main description remains 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?

The description is extremely short and front-loaded: the core purpose and the key behavioral caveat appear in the first sentence. It earns its place with no filler. However, the brevity comes at the cost of missing usage and behavioral context, so 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?

Given 10 parameters, no annotations, no output schema, and a large sibling list, the description is incomplete. An agent cannot tell what inputs are appropriate, what the tool returns, how it differs from playwright-url-ok or fetch-status, or what 'ok' means. The parameter descriptions hint at validation/discard behavior, but the overall tool contract is underspecified.

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 all 10 parameters. The description itself adds no parameter-level meaning beyond the schema, and the parameter list is confusingly heterogeneous (URL, city, JSON, timezone, search text, file path). The baseline of 3 applies because the schema does the heavy lifting, but the description does not help an agent understand why these parameters belong together or which are relevant for a URL check.

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

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

The description states a clear verb and resource ('Check whether a URL can be opened') and adds a useful behavioral note ('No browser is launched'). However, the tool name 'browser-url-ok' and the 10 heterogeneous parameters (ref, city, feed, host, json, path, zone, query, website) make the actual scope ambiguous: it is not clearly distinguished from siblings like fetch-status, normalize-url, web-fetch, or playwright-url-ok, and the description does not explain why unrelated parameters exist.

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

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

No guidance is given about when to use this tool versus alternatives such as playwright-url-ok, fetch-status, or normalize-url. The description only says what it does, not when it should be selected, and the parameter list suggests many unrelated use cases without any conditional guidance.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It reveals one trait—expression is discarded—but leaves ambiguous what the tool returns, whether it mutates anything, and how the 10 schema parameters are treated; the schema descriptions mention discard for some params, but the description does not clarify the overall 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 text is short and front-loaded, but for a 10-parameter tool with no annotations and no output schema, two sentences are under-specified rather than concise. 'Expression discarded' duplicates discard language that already appears throughout the parameter descriptions and adds no structural aid to the agent.

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

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

Given the tool's ambiguity, 10 optional parameters, no output schema, and no annotations, the description leaves the agent unable to construct a correct call: there is no expression field, no return contract, and no hint of what input produces a successful evaluation. The definition is materially incomplete.

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

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

Although schema coverage is 100%, the description adds no usable parameter semantics and in fact contradicts the schema by referring to an 'expression' that does not exist among the properties. The 10 parameters are left unexplained by the description, so the agent has no idea which (if any) carries the arithmetic expression.

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 verb and resource ('Evaluate a+b style arithmetic') but the input schema contains no expression parameter at all—instead it lists 10 unrelated optional fields such as url, city, feed, and json. A caller cannot map the stated purpose to any actual input, and no distinction is drawn from the many sibling shape-check tools.

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

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

There is no guidance on when to invoke this tool rather than one of its ~29 siblings, and no exclusions or prerequisites are given. The only instruction-like statement ('Expression discarded') is a behavioral note, not a usage directive.

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 disclose 'Page content is not stored', which is useful, but it does not explain why 10 unrelated optional parameters exist, whether they are ignored, or what the exact response behavior is.

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

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

Two sentences with no fluff: the output is front-loaded and the non-storage detail is a valuable extra. 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 is complex with 10 optional parameters, no annotations, and no output schema, yet the description only covers one narrow use case. An agent cannot tell whether it should pass url, host, website, or one of the other fields, or what the response structure looks like.

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

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

Schema description coverage is 100% and each parameter already has a clear description, so the schema does the heavy lifting. The description itself only mentions a URL and adds no deeper meaning beyond what the schema provides.

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. It is clear about what the tool does, but it does not distinguish it from siblings like fetch-status, normalize-url, or domain-shape, which may overlap.

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

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

There is no guidance on when to use citation versus the many URL-related siblings, nor any mention of when not to use it. The description provides no context for selecting this tool over fetch-status 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 behavior disclosure. It does add a useful privacy guarantee ('No identifiers are retained') and the schema notes several values are discarded, but it does not say whether the tool performs network access, reads files, has side effects, or how it handles multiple supplied fields. Operational behavior remains largely opaque.

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

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

The description is short, front-loaded with the action, and contains no fluff; the privacy sentence earns its place. However, extreme brevity makes it under-specified rather than efficiently complete, so it cannot earn a higher score.

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 10 optional parameters, no output schema, no annotations, and a large sibling family, the description fails to explain what result is returned, which parameter(s) to supply, what 'classification' means, or when to prefer this over obvious alternatives. An agent would be guessing 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 description coverage is 100%, so the baseline is 3 even though the tool description adds no parameter-specific meaning. The description does not clarify whether parameters are alternatives or combinable, but the individual schema descriptions already document each field, so the gap is acceptable.

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 generic action ('Show how this request is classified') but never defines what classification means, what categories are produced, or how the inputs relate to that classification. It is not a tautology, but it is too vague for an agent to know what 'compatibility' actually computes or how it differs from sibling shape/check 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 when-to-use or when-not-to-use guidance is provided, and no alternatives are named despite the large sibling family such as validate-json, normalize-url, and domain-shape. There is only an implied 'when you need classification,' which is not enough to route an agent reliably.

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

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

With no annotations, the description carries the burden of explaining side effects, return values, and limitations, but it only states that it splits a hostname and omits WHOIS/ownership. It does not disclose what output shape is produced, whether network access occurs, or that most input parameters are described in the schema as discarded. This is minimal non-misleading but insufficiently transparent.

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

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

The description is a single front-loaded sentence with no filler; the core action appears first and the negative scope ('without WHOIS or ownership data') is placed at the end. It earns its place as a terse summary. It loses a point because it is so short that important operational context is omitted, making it concise rather than comprehensive.

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

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

Despite the schema describing each parameter at 100% coverage, the tool description itself is incomplete: there are ten optional parameters with no required set, no output schema, and no explanation of what 'labels' looks like in the result. An agent cannot know whether to pass host, url, website, or something else, nor what the return value will be. This is not enough guidance for correct invocation.

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

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

Schema description coverage is 100%, so the baseline is 3; the parameter descriptions in the schema are individually clear (e.g., host is 'Public hostname', website includes robots.txt details). The tool description adds no mapping between its hostname-splitting behavior and the ten optional parameters, leaving which parameter to pass ambiguous. A 3 is appropriate 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 uses a specific verb ('Split') and resource ('a hostname into labels'), so an agent can tell this operates on hostnames rather than performing a generic lookup. The qualifier 'without WHOIS or ownership data' adds a clear non-goal. However, it does not distinguish domain-shape from sibling shape tools such as github-repo-shape or normalize-url, so it stops short of a 5.

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

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

There is no explicit guidance about when to choose domain-shape over its siblings or when not to use it beyond the implied 'no WHOIS/ownership' boundary. The description does not mention any prerequisites, required parameters, or alternative tools for ownership data. An agent is left to infer the intended use case from the name and one-sentence description.

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

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

With no annotations available, the description carries the behavioral burden and does convey key traits: it performs a HEAD request rather than GET, targets public URLs, and returns only a status. This meaningfully discloses the safety profile and response scope, though it remains silent on behavior for the other nine parameter types.

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

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

One sentence, active verb, clear object, and explicit output. Every word contributes, with no filler or repetition of the tool name.

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 10-parameter tool with no annotations and no output schema, a single URL-focused sentence is inadequate. It does not explain whether to pass one param at a time, what the status return value looks like, or how this tool relates to the many sibling probe/check 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 per the rubric the baseline is 3. The description adds no parameter-specific semantics beyond reinforcing that the URL should be public; it does not compensate for or add to the already-documented 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 names the operation (HEAD), the resource (public URL), and the result (status only), which separates it from content-fetching siblings like web-fetch. However, it presents only one use case while the schema exposes ten heterogeneous parameters (json, city, zone, path, website, etc.), so it under-describes the actual tool surface.

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

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

The phrase 'public URL' and 'status only' imply a lightweight pre-flight use for public endpoints, offering some usage context. Still, it gives no explicit when-to-use/when-not-to-use guidance and never names alternatives such as browser-url-ok or playwright-url-ok.

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

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

With no annotations, the description must carry the full behavioral burden. It discloses that a 'path' is discarded, but it does not state whether the operation is read-only, what it returns, whether authentication is needed, or what happens for malformed URLs. This is too thin for a parse 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 extremely short and front-loaded: the core purpose appears first_temp. No words are wastedikuha. However, it is so terse that it sacrifices necessary context, making it concise rather than fully structured.

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 10 optional parameters and no output schema or annotations, this description is inadequate. It does not tell the agent which parameter to populate, what the output looks like, or what 'path discarded' refers to. An agent would struggle to invoke this tool correctly with only the provided text.

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

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

Schema description coverage is 100%, so the baseline is 3. Each parameter has some description, but the description does not explicitly connect 'Figma file URL' to the `url` parameter, and the `path` parameter's schema meaning ('File path to check; no disk access') seems unrelated to the description's 'Path discarded.' The schema provides basic semantics, but the description adds little mapping clarity.

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

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

The description names a specific verb and resource: 'Parse a Figma file URL.' This distinguishes it from sibling shape tools like github-repo-shape or domain-shape by targeting Figma files. However, 'Path discarded' is ambiguous about which path and what the parse result is.

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 use when a Figma URL needs parsing but gives no explicit guidance about when to choose this tool over alternatives like normalize-url or browser-url-ok. There are no exclusions, prerequisites, or context cues, leaving the agent to infer the intended use case.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'no disk access,' which is a useful safety property, but does not disclose whether it performs network access, what it returns, error behavior, or whether it is read-only. For a tool with zero annotation coverage, 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?

The description is extremely short (two sentences) and front-loaded, which is good. However, it is under-specified, omitting critical details about the tool's behavior and scope. It is not appropriately sized for a tool with 10 optional parameters and no output schema; it is too sparse to be useful.

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 complexity of 10 optional parameters, no output schema, and no annotations, the description is grossly incomplete. It does not explain what 'safe' means, what the return value looks like, whether any side effects exist, or how to interpret the result. An agent has virtually no information to correctly select and invoke this tool.

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

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

Although the schema provides 100% description coverage for all 10 parameters, the tool's name and description imply that only 'path' is relevant, yet the schema includes many unrelated parameters (e.g., 'ref', 'url', 'city', 'feed'). The description does not clarify that these are extraneous or that only 'path' is used, which can confuse an agent about which parameter to supply. This ambiguity detracts from the schema's otherwise complete parameter documentation.

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

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

The description states a clear verb ('Check') and resource ('a path'), and notes 'looks safe' and 'no disk access'. However, it does not define what 'safe' means, nor does it differentiate from sibling tools like 'browser-url-ok' or 'domain-shape' that also perform shape/safety checks. The schema includes 10 unrelated parameters, which further obscures the actual scope of the 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 guidance on when to use this tool versus alternatives. No context is given about the problem it solves, when it should be preferred, or when another tool like 'browser-url-ok' or 'domain-shape' would be more appropriate. The description offers no exclusions or 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. It names the provider and return concept, but it does not disclose the output shape, expected input mapping, failure behavior, or side effects, and it never explains how 'a place' maps to the ten schema parameters.

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

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

The description is a single efficient sentence with no filler or repetition. However, it is shorter than necessary for a 10-parameter tool and omits the semantic link between the input parameters and the promised output.

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 drastically underspecified for a tool with 10 optional parameters and no output schema. An agent cannot confidently determine which input to provide, what the coordinate response looks like, or what happens on invalid input.

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

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

Schema coverage is 100% and every parameter already has an individual description, so the baseline is 3. The description adds no parameter-level meaning and fails to clarify which optional field is the 'place' that produces the latitude and longitude.

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 that the tool resolves a place to latitude and longitude and names Open-Meteo as the provider, which is a concrete and specific function. It is distinct enough from siblings like weather-hint, though it lacks an explicit verb such as 'gets' or 'returns'.

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

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

No guidance is given about when to use geo-hint instead of any sibling tool, such as weather-hint, timezone, or iana-zones. An agent must infer the intended use from the name and provider alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says 'parse' but does not state whether any network access occurs, what happens with invalid or non-GitHub URLs, whether the input is normalized, or what the output structure 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 a single, front-loaded sentence with no wasted words. It communicates the core action and target resource immediately, which is exactly what conciseness requires.

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 10-parameter optional input schema, the description is too sparse. It does not explain how to provide the GitHub URL, what the return shape is, how errors are handled, or whether non-url parameters are accepted or ignored.

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 implying that the 'url' parameter should be a GitHub URL and that owner/repo are extracted, but it does not clarify which of the 10 optional parameters are relevant or whether the other fields are ignored, leaving room for confusion.

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

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

The description states a specific verb ('parse'), a specific resource ('a GitHub URL'), and the expected result ('owner and repo'). It clearly distinguishes this tool from sibling shape tools like figma-url-shape or jira-key-shape by naming GitHub as the target domain.

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 like normalize-url or domain-shape. There is no 'use this for X, use that for Y' or any exclusion criteria; the only guidance is implied by the GitHub-specific purpose.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only adds that titles are discarded; it does not mention network access, rate limits, failure behavior, caching, or what the returned count looks like. The disclosure is minimal rather than misleading.

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 main action front-loaded and no filler. The second sentence adds a useful behavioral detail about titles, so 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, no output schema, and 10 optional parameters, the description is too thin. It does not state the return format, which parameters actually matter, or any operational constraints such as network or rate-limit behavior. The 'titles discarded' note hints at one behavior but leaves significant gaps.

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 of the 10 optional parameters has an explanatory description in the schema. The tool description itself adds no parameter-level meaning and does not explain which of the many optional parameters, if any, affect the Hacker News count.

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 precise action ('Count'), a specific resource ('Hacker News front-page stories'), and a temporal scope ('current'). This is enough to distinguish the tool from the sibling shape/status/fetch tools without needing to inspect the schema.

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

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

The intended use is implied: call this when you need the current count of Hacker News front-page stories. However, there is no explicit guidance about when not to use it or how it relates to sibling tools such as web-fetch or fetch-status.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only describes content ('common IANA timezone names') and not behavior. It does not state what is returned, whether the call is read-only, whether parameters are checked or discarded, or what side effects, if any, occur.

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

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

The description is short and free of filler, and the 'for clock calls' context is placed at the end. However, it is under-specified to the point of being a fragment rather than an informative tool definition, so the brevity is not fully an asset.

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 10-parameter tool with no output schema and no annotations, yet the description provides no invocation guidance, no return-value information, and no behavioral detail. The rich per-parameter schema descriptions help, but the tool-level description is far too incomplete for an agent to call this tool correctly and predict the 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 100%, so the input schema already documents all 10 parameters in detail. The description adds no parameter-level meaning beyond the schema, but per the baseline for high coverage, a 3 is appropriate; however, the description also fails to clarify which of the many optional parameters actually relate to 'iana-zones'.

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' is a noun phrase rather than a statement of action; it never says whether the tool lists, returns, validates, or suggests these names. It names a resource and hints at a use case, but an agent cannot tell exactly what invoking 'iana-zones' does from the description alone.

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

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

The phrase 'for clock calls' gives a weak contextual hint, but there is no explicit guidance on when to use this tool versus alternatives like 'timezone' or 'utc-time'. It does not state exclusions, prerequisites, or which sibling tools it substitutes for, so the agent is left to infer usage.

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

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

With no annotations at all, the description carries the full burden. It discloses that the tool performs a network fetch and only returns a counts summary, which is meaningful. However, it omits behavioral traits like error handling, missing robots.txt behavior, redirects, and rate limits.

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

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

The description is appropriately brief and front-loaded, making the core behavior immediately clear. It loses a point because it is so terse that it skips the crucial input mapping to the tool's parameters.

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

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

The tool has 10 optional parameters, no required parameters, no annotations, and no output schema, so the description is not complete enough to guide correct invocation. The description leaves an agent guessing which URL field to provide and what 'group counts' structurally represent.

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%, which sets the baseline at 3, but the description adds no parameter-level guidance. Given 10 optional parameters with several marked as 'discarded,' the description does not indicate which parameter(s) actually drive the robots.txt inspection, though the schema descriptions partly 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?

States a specific action ('Fetch a public robots.txt') and an exact output ('return group counts only'). This clearly identifies the resource being inspected and narrows the purpose enough to distinguish it from sibling fetch/shape tools.

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

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

The description gives no guidance on when to use this tool versus alternatives such as web-fetch, normalize-url, or domain-shape. The word 'public' hints at a precondition, but there are no explicit context cues, exclusions, or alternative tools 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 burden of behavioral disclosure, but it only says the key is discarded. It does not state whether validation is local, what output is returned, whether network access is involved, or what happens when the shape is invalid. This is a significant gap for a validation tool.

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

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

The description is compact, front-loaded with the core action, and free of filler. Both sentences are relevant, though the brevity is caused by under-specification rather than by efficient completeness.

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

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

Given ten optional parameters, no annotations, and no output schema, the agent still lacks essential context: the return value, how to construct the Jira key input, and whether side effects or network calls occur. The description is not complete enough 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 each parameter is already individually documented and the baseline is 3. The tool description adds no per-parameter meaning and fails to state which of the ten parameters should contain the Jira key; 'ref' is the closest hint because it is 'discarded after the shape check'. Since the description neither clarifies nor contradicts the schema, the baseline stands.

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 action and resource ('Check a Jira issue key shape'), so it is not a tautology, but it never defines what constitutes a valid shape and the schema exposes no 'key' parameter. With ten heterogeneous optional parameters, an agent cannot confidently map the stated purpose to an invocation. It also does not distinguish this tool from sibling shape-check tools.

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

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

There is no guidance on when to use this tool versus domain-shape, github-repo-shape, or figma-url-shape, nor any mention of the expected Jira key format such as 'PROJ-123'. The description leaves an agent to infer both the input source and the appropriate context, which is especially problematic given that no parameters are required.

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

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

The description discloses one important behavior: the body is discarded and only the HTTP status is relevant. With no annotations provided, the description carries the full burden, but it does not mention redirects, timeouts, side effects, or whether any request is actually made beyond the status check. It is minimally transparent but leaves key behaviors unspecified.

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

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

Two short sentences, front-loaded with the core purpose and followed by the key behavioral detail. There is no filler or redundancy; 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 definition is far too sparse for a tool with 10 optional parameters, no required parameters, no output schema, and no annotations. It does not explain what happens when no parameters are provided, what output format the status takes, how the other parameters relate to the operation, or how this tool differs from closely related 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?

Although the schema provides 100% parameter description coverage, the tool description does not help map the 'public library docs URL' to a specific parameter. The schema's 'url' description says 'HTTPS URL to normalize or cite,' which conflicts with the HTTP-status purpose, and the other nine optional parameters are left unexplained relative to the tool's stated behavior.

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

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

The description names a specific operation—returning an HTTP status for a public library docs URL—and even clarifies that the body is discarded. It is more specific than a generic fetch tool, though it does not explicitly differentiate itself from sibling tools like fetch-status or browser-url-ok.

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

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

The phrase 'public library docs URL' and 'body discarded' imply that the tool should be used when only an HTTP status is needed and not when the response body is required. However, the description gives no explicit when-not-to-use guidance and does not name alternatives among the many siblings with overlapping URL/status responsibilities.

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

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

With no annotations provided, the description carries the full behavioral burden and does add meaningful context: the website check is bounded, there is a 7-day free trial followed by $100/month, a hop redirect must be followed first, and task text is discarded. It still does not disclose the result/return behavior or full side effects of 'listing', but it goes well beyond a bare mutation statement.

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

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

The description is short and front-loaded with the core purpose. The pricing, hop instruction, and discard note are compact, though the UTM query string detail is arguably more specific than needed and 'start_here.hop' is unexplained.

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 10 optional parameters, no output schema, and no annotations, the description does not explain what the tool returns, how 'listing' manifests, or what happens after the hop. It also fails to differentiate from several closely named sibling tools, leaving a meaningful selection gap.

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

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

Schema description coverage is 100%, so the schema already documents every parameter. The description adds only generic behavioral notes such as 'Task text discarded' and the readiness-check scope, but does not provide additional per-parameter meaning. 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 first sentence identifies a specific action ('List a public API'), the target context ('where AI agents discover tools'), and a qualifying condition ('after a bounded website readiness check'). It is understandable, but 'list' is ambiguous between 'enumerate' and 'publish/register', and no sibling distinction is made from agent-ads-index or agent-tool-index.

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

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

No explicit when-to-use or when-not-to-use guidance is given, and none of the many sibling tools are mentioned as alternatives. The instruction to 'Follow start_here.hop first' hints at a workflow prerequisite but does not explain when this tool should be chosen over related index/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, the description carries the burden of behavioral disclosure. It does disclose a notable behavior ('Values discarded') but does not explain behavior for invalid JSON, empty objects, nested keys, or what output shape to expect.

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

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

The description is two short sentences with no filler, and the main action is front-loaded. Every word earns its place.

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 10 optional parameters, no output schema, and no annotations, yet the description is only a single declarative sentence. It does not say which parameter to use, how the JSON object should be supplied, whether a count is returned, or what happens on invalid input, making the definition incomplete for reliable invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description does not add per-parameter meaning beyond the schema; it only adds a general note about discarding values. It also does not clarify which of the 10 optional string parameters is meant to hold the JSON object.

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 keys') and resource ('a JSON object'), and adds a meaningful scoping detail ('Values discarded'). It is not a tautology and gives a clear sense of the tool's purpose, though it does not explicitly differentiate from sibling validation tools.

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

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

The description implies the tool is used when you need to count top-level keys in a JSON object and do not care about values. However, it gives no explicit when-to-use or when-not-to-use guidance, and no alternatives are mentioned despite many sibling tools existing.

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 is the only behavioral disclosure. It does state that query and fragment are dropped, which is useful, but it fails to mention any other behaviors – e.g., whether any parameters trigger network access (the 'website' parameter description suggests otherwise), how invalid URLs are handled, or what the return format is. The description's narrow scope leaves a large transparency gap.

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

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

The description is a single sentence that front-loads the main action and result. No wasted words; it is 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?

Given that the tool accepts 10 optional parameters of widely varying domains (city, feed, json, zone, etc.), the description is far too minimal. It only explains the URL handling, leaving the agent to wonder what the other parameters are for and whether they affect the result. This is a major 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 input schema has 100% description coverage for all 10 parameters, so the schema already documents each parameter. The description adds no additional meaning beyond what the schema provides – it only mentions 'URL', 'query', and 'fragment', which are concepts already covered. Baseline 3 applies.

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

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

The description uses a specific verb ('Return') and names the exact output fields (origin, host, path), plus a clear exclusion (query and fragment dropped). This clearly distinguishes it from sibling tools like browser-url-ok or web-fetch, which judge or fetch URLs rather than extract components.

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 mention of when to use this tool versus alternatives like browser-url-ok or fetch-status. The description provides no context for choosing this tool, no scenarios, and no exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses that it follows a redirect (start_here.hop) and that query text is discarded, which is useful. However, it omits other behaviors such as side effects, authentication, rate limits, or error conditions.

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 concise, consisting of two sentences with the main purpose front-loaded. It avoids unnecessary verbosity, though the technical redirect details (302, utm_source) could be considered extraneous 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?

Despite having 10 parameters and no output schema, the description does not explain how to invoke the tool or which parameters to use. It fails to guide the agent on the primary input, leaving significant ambiguity about the actual call.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-specific meaning beyond what the schema already provides; the only mention ('Query text discarded') duplicates the schema's note for the query parameter.

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

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

The description clearly states the tool finds a living people-search index (Ploid) and lists the returned content (CLI setup, docs, API, remote MCP hops). It is specific about the resource and outcome, though it does not explicitly differentiate from 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 on when to use this tool versus alternatives. The description does not mention any conditions, exclusions, or recommended contexts. It only states what it does, not when to choose 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 exist, so the description carries the full behavior-disclosure burden. It discloses that no browser is launched, but does not state whether a network request is made, what 'opened' means, side effects, rate limits, or how the non-URL 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 a two-clause sentence with no filler, front-loading the core action. Brevity comes at the cost of completeness, but that tradeoff is penalized in other dimensions.

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

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

For a tool with 10 optional parameters, no annotations, and no output schema, a one-sentence description is inadequate. It does not explain return semantics, what 'ok' means, or how the non-URL parameters relate to the stated 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?

Schema description coverage is 100%, so the structured schema already documents each parameter. The description adds no meaningful parameter-level semantics beyond the word 'URL', and it does not help the agent choose among the many 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?

States a specific action ('Check whether a URL can be opened') and a differentiator ('No browser is launched'), but the input schema exposes 10 unrelated parameters such as city, json, zone, and query that the description never accounts for. The stated purpose is therefore narrower than the tool's actual surface.

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 guidance is provided. The description does not name alternatives like browser-url-ok, web-fetch, or normalize-url, nor does it explain which of the 10 parameters to supply for which scenario.

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. The phrase 'Query discarded' is the only behavioral trait, and it duplicates the query parameter's schema description ('discarded after the length check'); it adds no new information and does not cover output format, error behavior, or handling of the other accepted parameters.

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

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

The description is extremely concise and front-loads the purpose in the first sentence. It is not bloated, though the second sentence is redundant with the schema's query parameter description.

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

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

Given ten optional parameters, no output schema, and no annotations, the description is incomplete: it does not specify the return value format, how character length is computed (code points vs UTF-16 units), or how the tool behaves with empty or multiple inputs.

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

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

Schema description coverage is 100%, so the baseline is 3. The schema's per-parameter descriptions, especially for 'query', are clear; however the tool description itself does not explain that the length check applies to 'query' only, nor what happens when multiple parameters are supplied.

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

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

The description states a specific verb ('Count') and resource ('characters in a search query'), which is enough to understand the core operation. It does not explicitly distinguish itself from similar counting tools like hn-front-count or memory-key-count, but the resource is clearly 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?

There is no guidance on when to use this tool instead of alternatives, no exclusions, and no mention that the 'query' parameter is the operative input among the schema's ten parameters. The agent must infer usage entirely from the parameter descriptions.

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 the behavioral burden. 'Short catalog' implies a passive, read-only reference, but it does not disclose whether parameters are ignored, how results are returned, or whether any network/disk access occurs. The schema hints that many inputs are 'discarded,' but the description itself adds little behavioral detail.

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, efficient sentence with no filler. It communicates the core identity of the tool immediately 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?

The tool has 10 optional parameters, no output schema, and no annotations, yet the description only offers a one-line purpose. It does not explain the return format, how parameters affect output, or why such varied parameters exist for a status-code catalog, so an agent has to guess at invocation semantics.

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 does not mention the parameters. The parameter descriptions are individually explicit, but they are not tied back to the catalog concept, leaving ambiguous how inputs like ref, json, or website relate to HTTP status codes.

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

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

The description says the tool provides 'a short catalog of common HTTP status codes,' which clearly identifies the resource and content domain. It lacks an explicit verb, but the noun 'catalog' still conveys that this is a reference/list tool and distinguishes it from siblings like fetch-status.

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

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

There is no guidance about when to use this tool versus alternatives. Despite sibling tools like fetch-status or browser-url-ok, the description never explains when an agent should choose the catalog instead of a live status check.

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

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

With no annotations, the description carries the full burden. It discloses one behavioral trait: 'Prompt discarded.' But it does not say whether the 10 input parameters are used, ignored, or validated, and the parameter descriptions conflict by suggesting real operations such as weather hints, JSON validation, and URL checks. This leaves the agent uncertain about the tool's actual behavior.

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

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

The description is extremely concise and front-loaded: the first sentence states the purpose, and the second adds a relevant behavioral note. Every word earns its place, but it is arguably too sparse given the large input schema and lack of an output 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 10 optional parameters, no annotations, and no output schema, so the description must provide the full context. It does not describe the return format, what the template contains, or how the parameters relate to the tool's behavior. The 'Prompt discarded' note is helpful but 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?

Schema description coverage is 100%, which normally earns a baseline of 3. However, the schema's parameter descriptions describe concrete actions like normalization, validation, and agent-readiness checks, while the tool description says the prompt is discarded. This is a meaningful semantic conflict that makes the parameter descriptions unreliable for deciding what to pass.

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

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

The description uses a specific verb and object: 'Return a three-step thinking template.' This is not a tautology and distinguishes the tool from the sibling tools, none of which are template generators. However, it does not explain what the three steps are or why an agent would need them, so the clarity is good but not complete.

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 a sibling, no stated conditions, and no exclusions. 'Return a three-step thinking template' only implies that the tool is useful when a template is wanted, but it never says what kind of prompt or context warrants the call.

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 disclosing behavior. It states 'Current time' implying a read operation, but it does not mention that all input parameters except 'zone' are discarded, nor does it cover return format, error handling, or whether it accesses external systems. The schema's many irrelevant parameters could mislead 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 a single efficient sentence with no wasted words. It is appropriately concise for a simple tool, though it could add a note about the 'zone' parameter without sacrificing brevity.

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

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

Given the tool has 10 parameters, of which only one is used, and no output schema, the description is incomplete. It fails to inform the agent about the parameter mismatch or the return value, leaving significant ambiguity for correct invocation.

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

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

Schema coverage is 100%, but the description adds nothing about parameter usage. It does not specify that only 'zone' is relevant, while the other nine parameters are misleadingly included. An agent could waste effort providing 'url', 'city', etc., without knowing they are ignored.

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 returns the current time for a given IANA timezone. It is specific about the resource (timezone) and the result, and implicitly distinguishes from siblings like 'utc-time' (UTC only) and 'iana-zones' (list of 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 on when to use this tool versus alternatives. For example, it could mention that 'utc-time' is for UTC, or that a valid zone name from 'iana-zones' is needed. The context is implied but 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?

With no annotations, the description carries the full burden of behavioral disclosure. It states the core output (current UTC timestamp) but does not mention that the 10 optional parameters are ignored or used only for validation, which is a significant omission. An agent might expect parameters to affect the result, which is misleading.

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, which is appropriately concise. It does not waste words and is easy to parse. However, it is so minimal that it may be under-specified rather than 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?

Despite having 10 optional parameters and no output schema, the description provides no context about what the parameters are for, how they affect the result, or any usage example. It is extremely incomplete for a tool with this many parameters, leaving an agent confused about correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds no meaning beyond what the schema provides, which is the baseline for high coverage. It does not explain how parameters interact with the output.

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

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

The description 'Current UTC timestamp' clearly states the tool's purpose: it returns the current UTC timestamp. It is specific and not a tautology. However, it does not differentiate from the sibling tool 'timezone', which could be confused with it.

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 usage guidance is provided. The description does not indicate when to use this tool versus alternatives like 'timezone', nor does it mention any prerequisites or exclusions. An agent has no clue about the context in which this tool is the right choice.

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

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

No annotations are provided, so the description carries the full burden. It does disclose a useful behavioral trait: 'the body is discarded', indicating no retention side effect. However, it does not describe the return contract, failure handling, or whether any other observable state is affected.

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 exactly two short sentences, with the operation stated first and the non-retention detail second. There is 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?

With no output schema and no annotations, the return value is undisclosed, and the description never tells an agent which of the ten possible inputs should be supplied. The schema covers individual field semantics, but the complete invocation contract is not captured.

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

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

Schema description coverage is 100%, so the schema already documents every parameter, which sets a baseline of 3. The description adds no guidance on how 'body' maps to the json parameter or which of the ten optional fields are 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 opens with a concrete check and names the exact resource: whether a body is valid JSON. This is enough to distinguish it from sibling shape/URL/file validators, none of which target JSON validation.

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

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

There is no statement about when to use validate-json over the many sibling check tools, nor any exclusion criteria or alternatives. The agent must infer usage entirely from the name and first sentence.

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

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

No annotations are provided, so the description carries the full burden. It does disclose an external dependency (Open-Meteo) and implies a read-only lookup, but it omits side effects, rate limits, error behavior, and the fact that many schema parameters appear to be ignored or 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, compact sentence with no extraneous words. It front-loads the core action and data source, which is appropriately concise for 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?

Given 10 optional parameters, no output schema, and no annotations, the one-sentence description is insufficient. It does not tell the agent which parameter to supply, what the response format will be, or how to handle the many unrelated schema fields, making correct invocation uncertain.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no meaningful parameter semantics beyond what the schema already provides—it only implicitly points to 'city' without clarifying relationships or resolving why most other fields are unrelated to weather.

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: retrieving the current temperature for a city via Open-Meteo. It is clear on its own, but it does not explicitly differentiate itself from sibling tools like geo-hint, and the 10-parameter schema with many unrelated fields muddies the tool's scope.

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

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

There is no guidance about when to use this tool versus alternatives such as geo-hint or timezone, nor any when-not-to-use conditions. The single-sentence description simply states the action, leaving all usage decisions to the agent.

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

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

With no annotations, the description carries the full burden, and it does disclose the key non-obvious behavior: body is discarded, only status and content type are returned, and the URL must be public. It omits details like redirects, timeouts, or error handling, but the most surprising trait is clearly flagged.

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 result is front-loaded and the key limitation ('Body discarded') is stated immediately.

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 10 optional parameters and no output schema, but the description only addresses URL-related behavior. It does not explain how parameters like ref, city, feed, json, path, zone, and query fit, leaving an agent without enough context to select the correct parameter 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?

Schema description coverage is 100%, so the baseline is 3. The description adds little beyond the schema, and it does not clarify how the 10 optional parameters, especially url versus website, relate to the stated 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?

The description names a specific operation — returning HTTP status and content type for a public URL, and clarifies the body is discarded, which distinguishes it from a content-fetching tool. It does not explicitly differentiate it from near-sibling tools like fetch-status or browser-url-ok, so it falls just short of a 5.

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

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

The description implies when to use it: when only HTTP status and content type for a public URL are needed and the body is not required. It offers no explicit when-not-to-use guidance or mention of alternatives among the sibling tools.

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

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

With no annotations, the description carries the full behavioral burden. It adds one data-handling note ('Title discarded after the call'), but does not disclose whether the check performs a network request, whether it is read-only, what it returns, or how failures are reported. The 'discarded' phrasing hints at a validation-only tool but is not reconciled with the stated purpose.

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

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

The description is very short and front-loaded with the main purpose. The second sentence is somewhat vague, but there is no fluff or unnecessary detail.

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

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

For a tool with 10 optional parameters, no output schema, and no annotations, this description is severely incomplete. It does not explain which parameter carries the Wikipedia title, what the result looks like, when to use the tool, or how it relates to siblings, making correct invocation impossible.

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 tool description provides no mapping to parameters, and none of the 10 optional strings (city, zone, json, feed, host, path, website, etc.) is described as the Wikipedia title. The description therefore fails to help an agent decide which parameter to pass 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?

The description states a specific operation ('Check whether a Wikipedia title exists'), but it is essentially a restatement of the tool name and is not actionable: the schema exposes 10 unrelated optional string parameters and no 'title' parameter. It also does not distinguish this tool from sibling 'ok'/'shape' checkers.

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 browser-url-ok or file-path-ok. The description only implies a use case (verifying a Wikipedia title) but does not say how to select the tool or which parameter to provide.

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