Australia/Darwin clock

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true. The description adds useful behavioral context beyond that: it returns CLI setup, how-it-works, skill file, and remote MCP hops, and explicitly states that task text is discarded. There is no contradiction with the annotations.

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

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

The description is a single sentence that front-loads the action and resource, then lists outputs compactly. Every phrase earns its place, with no filler or redundancy.

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

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

In the absence of an output schema, the description does explain the return content at a useful level (CLI setup, how-it-works, skill file, remote MCP hops). The parameter schema handles the remaining detail. A small gap is the unexplained term 'Monid' and no explicit statement of which parameters to populate, but overall it is sufficient for a discovery tool.

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

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

Schema description coverage is 100%, with each of the seven parameters having its own description in the input schema. The tool description itself adds no parameter-specific meaning beyond the general note that task text is discarded, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Find') and names a distinct resource ('public pay-per-call tool gateway (Monid)'). It also lists concrete outputs: CLI setup, how-it-works, skill file, and remote MCP hops. It does not explicitly contrast with sibling tools like web-fetch or fetch-status, but the discovery/gateway focus is clear enough.

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

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

The intended use is implied: use this when you need a Monid pay-per-call tool gateway and its setup/skill files. However, the description gives no explicit when-not-to-use guidance or alternatives, even though several siblings are plausible alternates for fetching or validating URLs.

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

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

The description discloses exactly one behavior: no browser is launched. It does not say whether the tool makes network requests, whether it is read-only, what determines 'opened,' or that most parameters are discarded after the check. With no annotations, the side-effect profile is largely unknown, placing the full disclosure burden on the description.

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

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

Two short sentences, both carrying essential information: the action and the key behavioral exclusion. No wasted words, and the main purpose is front-loaded.

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

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

The tool accepts 9 heterogeneous parameters and has a large sibling family, yet the description only addresses URL checking. It omits the output format, success criteria, how the other parameters are handled, and any relationship to fetch-status or playwright-url-ok. This is severely inadequate for an agent to select and invoke the tool correctly.

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

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

The input schema already provides descriptions for all parameters (high coverage), so the baseline is 3. The tool description adds no parameter-level semantics beyond the generic phrase 'a URL,' and it does not clarify the role of the other eight parameters.

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

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

The description states a clear action ('Check whether a URL can be opened') and distinguishes from browser-based checks via 'No browser is launched.' However, it is vague about what 'opened' means (syntax, HTTP reachability, DNS?) and ignores the fact that the schema accepts many non-URL parameters (ref, city, json, path, feed, host), making the described scope narrower than the actual tool.

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

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

The 'No browser is launched' sentence implies this is the lightweight alternative to browser-driven tools like playwright-url-ok, but no explicit when/when-not guidance or alternative names are given. An agent must infer when to choose this 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?

'Expression discarded' does disclose that evaluation leaves no persistent state, which is a useful behavioral trait beyond the schema. However, with no annotations and no output schema, the description must also disclose what is returned, what inputs are accepted, and what failure looks like; it does none of that.

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 very short and front-loaded, which is structurally good. But this is under-specification rather than efficient completeness: the brevity hides the fatal omission of how an expression is provided to the tool.

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

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

With no annotations, no output schema, and seven schema parameters that have no apparent relationship to arithmetic, the description is far too incomplete for an agent to call this tool correctly. The core evaluation behavior is mentioned but cannot be operationalized from the available information.

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

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

The schema documents seven unrelated parameters—ref, url, city, feed, host, json, path—and the description never identifies which one carries the arithmetic expression. Since there is no 'expression' field at all, the description not only fails to add semantic value but actively conflicts with what the schema shows.

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

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

The description says 'Evaluate a+b style arithmetic,' which names a verb and a resource, but it nearly restates the tool name and never explains how the expression is supplied. Because the input schema has no 'expression' parameter, the stated purpose cannot be mapped to an invocation, making it effectively misleading in context.

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 calc-eval over any alternative or when not to use it. The only usage hint is 'a+b style' syntax, but it is not connected to any request field, so an agent cannot infer valid input composition.

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

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

No annotations are provided, so the description carries the behavioral burden. The sentence 'Page content is not stored' is a meaningful privacy and side-effect guarantee. However, the description does not disclose broader behaviors such as how the other parameters are handled, network requirements, or any 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 brief, front-loaded, and free of filler. The second sentence earns its place by stating the non-storage policy. Given the breadth of parameters, it is somewhat under-informative, but structurally it is efficient.

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

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

The definition is incomplete for a tool whose schema exposes seven heterogeneous parameters and no output schema. It explains only the URL/host/scheme/status use case and never hints at how ref, city, feed, json, path, or host fit into the tool, leaving an agent reliant on sparse schema hints.

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

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

The input schema already provides descriptions for all seven parameters, including discard behavior, so schema coverage is high. The tool description adds little beyond reinforcing the URL parameter and does not clarify how the other parameters relate to the operation.

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

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

The first sentence states a specific, observable outcome: return host, scheme, and HTTP status for a URL. It is clear about the core operation, but it does not explicitly distinguish itself from siblings like normalize-url or fetch-status, and it ignores several schema properties.

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

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

The description provides no guidance on when to use this tool instead of alternatives such as fetch-status, normalize-url, web-fetch, or validate-json. The URL use case is implied, but no exclusions or selection criteria are offered.

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 phrase 'No identifiers are retained' provides a useful privacy guarantee, but the description does not disclose what output the classification produces or what side effects or expectations exist. With no annotations present, this is too thin to fully characterize 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 two short sentences with no filler. The main action is front-loaded, and the privacy note is relevant and 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?

With seven parameters, no output schema, and no annotations, the description is far too incomplete. It does not explain what classification output to expect, how to interpret it, or how this tool relates to the sibling validation tools, making it difficult for an agent to call 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?

Each parameter already has a schema description, so schema coverage is high and the description does not need to re-document parameters. The description adds no cross-parameter or classification-specific meaning, so the baseline score of 3 is appropriate.

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

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

The description states a specific action ('Show how this request is classified') but never defines what classification means or what categories are used. It does not distinguish this tool from the many sibling shape-check tools, so the purpose remains somewhat vague.

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 for when to use this tool versus alternatives. There are no exclusions, prerequisites, or references to sibling tools, so the agent is left without a basis for selection.

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

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

No annotations are present, so the description carries the full burden of describing behavior. It does disclose one useful trait (no WHOIS or ownership enrichment), but it does not explain return behavior, handling of invalid hostnames, or why seven unrelated parameters exist in the schema.

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

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

The description is a single sentence with no filler, and the core verb and subject appear immediately. It is concise and easy to parse, although its brevity leaves important usage questions unanswered.

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

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

With seven parameters, no annotations, and no output schema, a one-sentence description is insufficiently complete. It does not explain how 'host' relates to the other accepted fields, what the returned labels look like, or when this tool should be used instead of a more general URL or fetch tool.

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

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

The input schema already documents all seven parameters, so the baseline is 3. The description only reinforces that a hostname is split and adds no extra meaning for the other six parameters such as url, city, feed, json, ref, and path.

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

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

The description names a specific operation ('Split a hostname into labels') and a clear resource, and it adds a boundary ('without WHOIS or ownership data'). It does not explicitly differentiate itself from sibling shape tools, but the verb and subject are unambiguous.

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

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

No guidance is given on when to prefer this tool over alternatives like normalize-url or web-fetch. The only contextual hint is the negative constraint that WHOIS/ownership data is not returned, which is helpful but not sufficient for an agent to select this confidently.

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

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

With no annotations, the description carries the behavioral burden. It meaningfully discloses the method (HEAD), target visibility (public), and output scope (status only). It stays silent on failure modes, timeouts, and the fact that most schema fields are discarded rather than fetched.

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 with no filler; the verb and resource are front-loaded and every word contributes to the core behavior.

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

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

The tool has seven parameters and no output schema, but the description covers only the URL case. It does not define what 'status' actually looks like, how the non-URL inputs are handled, or when to prefer this over sibling URL-check tools, so the selection picture is 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?

All seven parameters already have descriptions in the input schema, so the baseline is 3. The description adds no parameter-level meaning and narrows the tool to URLs, leaving the relationship of ref, city, feed, json, and path to the operation unexplained.

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 (HEAD), resource (public URL), and outcome (status only), so it is not a tautology and is broadly distinguishable from content-fetching siblings. However, it does not distinguish this from sibling URL-check tools like browser-URL-ok or playwright-URL-ok, and it ignores the other parameter kinds in the schema.

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

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

'Status only' implies this is for lightweight availability checks, which gives some usage context. But it never names alternatives or states when not to use it, leaving selection among web-fetch, browser-URL-ok, playwright-URL-ok, and normalize-URL to inference.

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

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

There are no annotations, so the description must carry the full behavioral burden. It discloses one behavior—'Path discarded'—but does not explain what parsing does, whether it validates or normalizes, what is returned, or whether any side effects occur. The behavioral transparency is therefore minimal.

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

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

The description is highly concise and front-loaded, with every word contributing. The second fragment 'Path discarded' is compact and informative, though the brevity leaves key behavioral and structural details out, so it does not reach 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?

With no output schema and no annotations, an agent cannot tell what the tool returns or what a valid Figma URL shape is; 'parse' is underspecified. The description is adequate only to guess the tool's rough purpose, not to confidently invoke and use the result 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?

All input schema properties have descriptions, so the baseline is 3. The description adds value by specifying that 'url' should be a Figma file URL and that the path is discarded, but it leaves the many unrelated properties (ref, city, feed, json, host) unexplained in the context of this tool, and the 'path' statement is ambiguous against the schema's 'File path to 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 uses a specific verb and resource: 'Parse a Figma file URL.' This makes the tool's target clear and distinguishes it from other shape-related tools by URL kind. The phrase 'Path discarded' adds a notable scope detail, though it does not explicitly name sibling tools or state what the shape check produces.

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 tells the agent that this tool applies to Figma file URLs, so the usage context is implied. However, it gives no explicit guidance about when to choose this tool over sibling shape tools such as github-repo-shape or jira-key-shape, and no exclusions or prerequisites are stated.

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

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

With no annotations, the description carries the full burden of explaining behavior. It only states 'No disk access,' which implies a side-effect-free check, but it does not describe what constitutes 'safe,' what the return value looks like, or whether errors are thrown. The behavior is 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 extremely concise: two short sentences with no redundant wording. Every word contributes either to the purpose or to a key behavioral constraint. It is well-structured and easy to parse.

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

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

Given the tool has 9 optional parameters and no output schema, the description is far too minimal to be contextually complete. It lacks details about return format, error behavior, parameter interactions, and why unrelated parameters are accepted. An agent would struggle to use this tool correctly based solely on the description.

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

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

The schema has 100% description coverage for all 9 parameters, so the baseline is 3. However, many parameter descriptions seem unrelated to the tool's stated purpose (e.g., 'city name for a public weather hint', 'IANA timezone name'), and the tool description itself adds no clarification about why these parameters exist or how they relate to checking a path. The schema descriptions are present but confusing.

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

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

The description clearly states the tool's core action: 'Check whether a path looks safe.' It identifies the resource (a path) and the verb (check), and the tool name aligns with that purpose. It is slightly ambiguous what 'looks safe' means, but the intent is understandable.

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

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

The description provides no guidance on when to use this tool versus any alternative. With many sibling tools like browser-url-ok, fetch-status, and normalize-url, there is no indication of the appropriate context or selection criteria. 'No disk access' hints at a constraint but does not explain usage scenarios.

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

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

The description discloses the essential behavior: a lookup via Open-Meteo that returns coordinates, and the schema reinforces that inputs are discarded. However, there are no annotations and the description does not cover output format, approximate 'hint' behavior, or failure modes.

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

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

The description is one concise sentence without filler, and it front-loads the purpose as well as the external service. It could be slightly more informative, but it does not waste words.

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

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

With seven parameters, no output schema, and no annotations, the description is too sparse to fully guide an agent: it does not specify which parameter to populate, what the response looks like, or how this differs from related tools. The schema hints like 'discarded after the call' do some work, but the overall invocation contract remains implicit.

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

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

All seven parameters have their own schema descriptions, so schema coverage is high and the baseline is three. The description adds no explicit mapping from 'a place' to the `city` parameter and leaves the other six parameters irrelevant, but the schema already provides per-parameter meaning.

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 latitude and longitude for a place and names Open-Meteo as the source, so the core purpose is clear. It is a noun phrase rather than an imperative, and it does not explicitly differentiate geo-hint from sibling tools like weather-hint.

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

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

There is no guidance about when to use this tool versus alternatives such as weather-hint, nor any mention of prerequisites or fallbacks. The single sentence tells an agent what the tool does, but not when to invoke it.

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

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

No annotations are present, so the description must disclose behavioral details itself. It only says 'parse owner and repo', without clarifying behavior on invalid URLs, exact accepted URL formats, whether normalization occurs, or how the parsed result is returned. Minimal behavioral disclosure for a tool that likely validates or normalizes input.

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

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

The description is a single clear sentence with no wasted words, and the key action is front-loaded. It lacks any structural elaboration, but for the narrow claim it makes, it is appropriately concise.

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

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

With six parameters, no annotations, and no output schema, a one-sentence description is insufficient. It does not explain the expected input/output shape, the role of the other parameters, error handling, or the return value—all important for an agent to invoke this correctly among a large group of similar shape tools.

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

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

The schema documents every parameter, so the baseline is adequately covered. The description adds one useful detail—that the URL should be a GitHub URL—which the schema's 'HTTPS URL to normalize or cite' does not specify. However, it does not clarify which parameter is the primary input or how the many other parameters relate to this tool.

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

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

The description states a specific action ('Parse'), a concrete target ('owner and repo'), and a source format ('GitHub URL'). This makes the tool's core function clear and distinguishes it from sibling shape/URL tools, though it does not explicitly name the alternative tools it is not.

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

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

There is no guidance on when to choose this tool over nearby siblings like normalize-url, domain-shape, or figma-url-shape. The description implies the use case (parsing GitHub URLs) but gives no conditions, exclusions, or alternatives.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure. It adds only that titles are discarded, but fails to mention output shape, data source behavior, rate limits, or side effects. For a simple count tool this is minimal but not fully transparent.

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

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

The description is two short sentences with no filler. The primary action is front-loaded, and the second sentence adds a meaningful output constraint. 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 an 8-parameter input schema and no output schema, yet the description explains neither which parameters are relevant nor what a caller must supply. It also does not differentiate from sibling tools. For an agent selecting and invoking the tool, the description is too sparse relative to the schema complexity.

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

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

The input schema already describes all eight parameters, so schema coverage is high and the baseline is 3. The description adds no parameter-level meaning and does not clarify how parameters like ref, city, or path relate to counting Hacker News stories. This is acceptable because the schema provides descriptions, but the connection between params and tool behavior remains unclear.

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

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

The description states a specific verb and resource: 'Count current Hacker News front-page stories.' This is not a tautology and gives a clear sense of the tool's operation. The added 'Titles discarded' helps clarify the output scope, though it does not explicitly distinguish from other 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 provided on when to use this tool versus alternatives such as web-fetch or fetch-status. The description implies the use case (need the count of HN front-page stories) but offers no exclusions, prerequisites, or comparative context.

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

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

No annotations are present, so the description must disclose behavior, but it says nothing about return format, side effects, required arguments, or failure modes. 'Common IANA timezone names' describes content, not what the tool does when invoked.

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

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

The description is front-loaded and only six words long, with no filler. However, it is an incomplete noun phrase rather than a clear behavioral sentence, so the brevity veers into under-specification.

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

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

With no output schema and no annotations, the description should state what the tool returns and how to invoke it; it does neither. The presence of seven unrelated-looking parameters makes the missing call contract more damaging. The sentence gives only a category hint, not usable complete guidance.

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

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

The input schema describes all seven parameters, some with notes like 'discarded after the shape check', so schema coverage is high and the baseline is 3. The description adds no parameter meaning, and it does nothing to explain why a timezone tool accepts parameters like 'ref', 'json', or 'path'; this is confusing but not contradictory.

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' identifStyles a resource and an intended context, but it lacks a verb—an agent cannot tell whether this tool lists, validates, returns, or stores timezone names. It does however loosely distinguish itself from the timezone/utc-time sibling tools by being about the names themselves.

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' implies the tool should be used with timezone/utc-time calls, giving some context. But it never states explicitly when to use this tool versus alternatives, mentions no exclusions, and leaves the workflow to inference.

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

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

With no annotations present, the description carries the behavioral burden. It clearly discloses that the tool fetches a remote public resource and returns only aggregate counts rather than the full robots.txt content, but it does not mention failure behavior, network side effects, or return format.

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

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

A single front-loaded sentence with no filler. Every word earns its place, and the phrase 'group counts only' immediately scopes the operation.

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

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

With no output schema, no annotations, and seven parameters, this one-sentence description is insufficient for correct invocation. The agent is left to guess which parameter selects the robots.txt and what the response shape will be.

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

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

All seven parameters have schema-level descriptions, so schema coverage is high and the baseline is 3. The description adds no parameter-level meaning and does not tell the agent which parameter actually identifies the robots.txt to fetch.

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

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

Description states a specific verb ('Fetch'), a specific resource ('public robots.txt'), and a precise output scope ('group counts only'), making it distinguishable from general fetch tools like web-fetch. It does not define what 'group counts' means or name sibling alternatives, 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?

No guidance is given about when to use this tool versus alternatives such as web-fetch, fetch-status, or status-catalog. The word 'public' implies a condition, but no exclusions or alternative routing guidance is provided.

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

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

No annotations are present, so the description carries the burden of behavioral disclosure. It does disclose that the key is discarded, but it says nothing about the return value, whether any external lookup occurs, or how invalid shapes are handled. This is minimal transparency beyond the schema's per-parameter discard notes.

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, and the main action is front-loaded. The privacy note is compact and does not repeat the schema at length. This is appropriately concise for the limited content it provides.

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

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

There is no output schema, so the description should explain what the tool returns, but it does not. It also fails to tie the Jira key to any of the seven input properties, making the tool difficult to invoke correctly. The schema's property descriptions are helpful but do not compensate for these two critical 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?

The input schema has descriptions for all 7 properties, so schema coverage is high and the baseline is 3. The description adds no parameter-level meaning and uses the term 'key' without mapping it to any of the declared properties, leaving ambiguity about where the Jira key should be provided.

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

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

States a specific verb and resource: 'Check a Jira issue key shape.' The Jira qualifier distinguishes it from sibling shape tools. However, it doesn't explain what result is returned or which input carries the key, so the purpose is clear but not fully actionable.

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

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

No guidance on when to use this tool versus sibling shape tools, nor any prerequisites or exclusions. The only usage signal is the implied Jira context from the name and description, which is not enough for reliable tool selection.

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

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

The description discloses one behavioral trait: 'Body discarded.' But there are no annotations to rely on, so the description bears the full burden of behavioral transparency. It does not mention whether a network request is made, how the URL is normalized, what 'hint' means, or any side effects. The coverage is far too 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 concise—one sentence with no unnecessary words. The information it does include is front-loaded, but the brevity comes at the cost of essential context, so it is concise yet incomplete.

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

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

With seven heterogeneous parameters, no annotations, and no output schema, a single sentence is far from sufficient. An agent would not know which parameters are relevant for a 'library docs URL,' what the expected input format is, or what 'hint' implies about the response. The description is inadequate for the tool's complexity.

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

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

The input schema provides descriptions for all seven parameters, so schema coverage is effectively 100%. The description itself adds no parameter-level meaning, but the baseline of 3 applies because the schema already documents each parameter individually.

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 ('HTTP status') and resource ('public library docs URL'), giving a basic sense of the tool's function. However, the tool name 'lib-docs-hint' and the heterogeneous input schema (ref, city, feed, json, path) create ambiguity about the actual scope, and it does not distinguish itself from siblings like fetch-status or browser-url-ok, which also deal with HTTP status and URLs.

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 conditions, exclusions, or sibling comparisons are provided, so an agent cannot determine whether to choose this over fetch-status, normalize-url, or web-fetch.

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. 'Values discarded' does disclose that values are not returned, which is useful. But the description is silent on whether nested keys are counted, what object is counted when all parameters are optional and described as 'discarded,' what errors look like, and why the json parameter is framed as validation input rather than the object to count. The mismatch between the tool's stated purpose and the schema's parameter descriptions adds ambiguity instead of transparency.

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

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

The description is two short sentences (7 words) with the core operation front-loaded and zero filler. Both sentences earn their place. However, at this scale of context — 9 parameters, 27 siblings, no annotations — the terseness verges on under-specification, so it does not quite earn a 5.

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

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

Given 9 optional parameters, no annotations, no output schema, and 27 siblings, the description is completely inadequate. It does not state what the return value is (beyond an implied count), what happens when called with no arguments, which parameter (if any) is the input, or how this differs from validate-json. An agent cannot determine how to invoke this tool correctly — it would not know whether to pass json, any other parameter, or nothing at all.

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

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

Schema coverage is 100%, so the baseline is 3, but the schema descriptions themselves are misleading: every parameter ends with 'discarded after...' (e.g., 'Git ref name; discarded after the shape check,' 'Search text; discarded after the length check'), reading like leftovers from other tools. The json parameter is described as validation input, which contradicts the description's counting purpose. The tool description adds no clarification about which parameter supplies the JSON object, so the overall semantics actively confuse rather than inform.

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

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

The description names a concrete operation — 'Count keys in a JSON object' — with a clear verb and resource, and adds a meaningful scope line ('Values discarded'). It is not a tautology and is conceptually distinct from validate-json. However, it is vague about the input source: the schema's only JSON-carrying parameter (json) is described as 'JSON text to validate; discarded after the check,' so an agent cannot tell which object is being counted or whether the json parameter even matters.

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. With 27 siblings including validate-json, hn-front-count, search-query-len, and domain-shape — tools that also perform checks/counts — there is no statement of when to choose this tool over them, and no when-not or alternative conditions. The agent is left to infer relevance purely from the name and 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 present, the description carries the behavioral disclosure burden. It does disclose an important transformation—query and fragment are dropped—but it does not describe the output format, behavior for invalid URLs, or what happens with the many other input parameters. This is a meaningful but not severe 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 two sentences with no filler. The primary purpose is front-loaded and the limiting behavior follows immediately, making it easy for an agent to parse quickly.

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

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

For a simple normalization operation with high schema coverage, the description is minimally adequate, but there is no output schema and the description does not state the exact return structure or clarify which parameter among the seven should be used. An agent can likely infer the intent, but ambiguity remains.

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

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

The input schema has descriptions for all seven parameters, so schema coverage is high and the baseline is 3. The description adds little beyond naming the URL as the core input, and does not clarify how the separate 'host' and 'path' parameters relate to the returned origin, host, and path.

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

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

The description states a clear action ('Return') and resource ('origin, host, and path for a URL'), and immediately specifies the key behavior that query and fragment are dropped. It is specific enough to be useful, but it does not explicitly distinguish this tool from sibling URL-related tools like browser-url-ok or fetch-status.

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

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

The description implies when to use the tool: when a caller needs origin, host, or path components and does not need query or fragment. The 'Query and fragment are dropped' clause provides an implicit exclusion, but no alternative tools or explicit when-not-to-use guidance are mentioned.

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

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

The only disclosed behavior is 'No browser is launched,' which adds one useful constraint. However, it does not explain what 'can be opened' actually means (static check? DNS? HTTP status?), what side effects or side effects are absent, what happens to inputs, or whether there are rate limits. With no annotations, the description carries the full burden and does not meet it.

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

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

Two short sentences, no redundant words. The 'No browser is launched' sentence adds a distinct behavioral detail. But the under-specification limits usefulness.

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

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

Despite a surface-simple schema, the tool definition is incomplete: no annotations, no output schema, seven optional parameters with ambiguous semantics, and a description that does not explain the actual behavior or return value. An agent cannot reliably decide when to call this tool or what to expect from it.

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

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

All seven parameters in the schema have descriptive text, so schema coverage is 100%. The description itself adds no parameter-level meaning and does not clarify which parameter is primary or how the non-URL parameters relate to 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 verb and resource ('Check whether a URL can be opened'), but the input schema includes multiple non-URL parameters (city, feed, json, path, ref) with descriptions about shape checks and discarding, which conflicts with the single-purpose reading. It does not differentiate from siblings like normalize-url or fetch-status, aside from the 'No browser is launched' note.

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 instead of alternatives like browser-url-ok, normalize-url, or web-fetch. There is no mention of prerequisites, exclusions, or intended context.

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

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

With no annotations present, the description must carry the safety burden, and 'Query discarded' does convey that the query is not stored or reused. It does not state whether the many unrelated optional parameters are ignored, but for a pure counting tool the main side-effect concern is addressed.

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 sentences with no filler, and the core verb 'Count' is front-loaded. The second sentence earns its place by clarifying data handling.

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

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

Despite having 9 optional parameters and no output schema, the description gives no return shape and no guidance on how the other fields relate to the query-counting task. The parameter descriptions cover individual semantics but not the overall invocation contract, leaving an agent uncertain about output or whether extra fields are processed.

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

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

The schema provides 100% parameter descriptions, so the baseline is 3. The description adds no parameter meaning beyond identifying the search query as the thing counted; it does not clarify the role of the other eight optional fields or how they relate to the query.

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

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

The description states a specific operation—count characters in a search query—and adds that the query is discarded. This makes the core function unambiguous, though it does not explicitly differentiate itself from sibling counting 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 intended use is implied by the verb phrase: call it when a search-query character count is needed. However, it provides no explicit when-not-to-use guidance or mention of alternatives, so the agent must infer routing from the name and 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?

No annotations are provided, so the description must carry the behavioral disclosure burden, but it only says 'short catalog' and reveals nothing about side effects, input handling, or what happens to passed values. The input schema hints at 'discarded' values and 'no disk access', but the main description does not disclose these behaviors.

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

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

The description is a single short sentence, which is structurally simple and front-loaded, but the brevity is under-specification rather than useful compression. It omits essential information about what the tool does with its inputs and how it relates to the rest of the toolset.

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, seven heterogeneous parameters, and a one-sentence description, an agent has insufficient information to know what inputs to provide or what the tool will return. The mismatch between the 'HTTP status codes' description and the URL/city/JSON/path parameters makes the tool nearly impossible to invoke correctly with confidence.

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

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

All seven parameters have individual schema descriptions, so schema coverage is effectively 100%. The main description adds no parameter-level meaning, but the schema already explains each parameter's role at a basic level, keeping this at the baseline score.

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

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

The description identifies the resource as a catalog of common HTTP status codes, but lacks an action verb and does not clarify how the seven unrelated input parameters fit. It also does not distinguish itself from siblings like fetch-status, leaving the tool's actual function ambiguous.

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

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

There is no guidance on when to use this tool versus alternatives such as fetch-status or validate-json. The description does not state whether it should be used to look up status codes, validate inputs, or normalize URLs, so an agent cannot make an informed selection.

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

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

The description discloses a key behavioral trait: 'Prompt discarded,' indicating that the input does not influence the returned template. However, with no annotations supplied, the description carries the full burden and does not explain side effects, output behavior, or what happens if parameters are invalid. It adds some transparency but not enough for a tool with seven inputs.

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

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

The description is very short and front-loads the core behavior in its first sentence. The second sentence is also useful because it warns that input is discarded. It is efficient, though slightly cryptic because 'Prompt' is capitalized and no parameter of that name exists.

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 seven heterogeneous parameters and no output schema, the description is under-specified. It states the return object in general terms—'three-step thinking template'—but gives no output structure, examples, or indication of whether any parameter is ever required. An agent cannot fully determine how to correctly invoke this tool beyond guessing it is a constant-output utility.

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

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

The input schema already describes all seven parameters, including the fact that each is discarded after a check, so schema coverage is high. The description adds only 'Prompt discarded,' which does not clarify how a caller should choose or populate ref, url, city, feed, host, json, or path. The description contributes no meaningful semantic value beyond the schema.

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

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

The description uses a specific verb and object—'Return a three-step thinking template'—so the core behavior is clear. The second sentence clarifies that the prompt is ignored, which helps define what the tool does not do. It does not explicitly differentiate itself from sibling tools, but none of the siblings obviously overlap with a thinking-template 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 about when to use this tool versus alternatives. The description implies it can be used whenever a three-step thinking template is needed, but it never states conditions, exclusions, or how it relates to sibling shape-check and fetch utilities. An agent would have to infer when to invoke it.

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

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

No annotations are present, so the description must carry the full behavioral burden. It discloses only that the tool gives the current time; it does not explain the return value, error behavior, DST handling, or the fact that the schema contains many unrelated fields whose descriptions say they are 'discarded'. The main 'iana' parameter is not described, adding ambiguity.

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?

It is a single, front-loaded sentence with no filler, which is appropriately concise for a simple tool purpose. It could be longer to cover parameter mapping, but the conciseness itself is not the problem.

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 schema's eight parameters, several with 'discarded' descriptions, and no output schema, the description is not complete enough. An agent cannot confidently determine which parameter to populate or whether the other fields are ignored. A complete description would explicitly state that 'iana' holds the timezone and that other fields are 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?

The schema contains an 'iana' string property with no description, while the tool description hints that a named IANA timezone is the input. This adds minimal meaning beyond the schema, but the description never explicitly maps the IANA timezone input to the 'iana' parameter or clarifies that the other schema fields are irrelevant for this tool.

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

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

The description states a specific verb ('Current time') and resource ('a named IANA timezone'), so an agent can tell this tool returns timezone-aware current time and can distinguish it from siblings like 'utc-time'. It does not explicitly describe the output format or mention the relevant parameter, but the core purpose is clear.

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

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

The description implies when to use the tool: whenever a current time in a named IANA timezone is needed versus UTC or other generic time tools. However, it does not explicitly contrast with sibling tools or state exclusions, such as when to prefer 'iana-zones' or 'utc-time'.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only says 'Current UTC timestamp.' It does not disclose that the nine optional parameters appear to be discarded or ignored, nor does it describe the timestamp format or any side effects. This is a notable transparency gap for a tool with a complex-looking schema.

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

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

The description is extremely short and front-loaded, with no filler. However, it is closer to a label than a complete description and under-specifies the tool's behavior relative to its nine parameters and missing 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 nine optional parameters, no annotations, and no output schema, yet the description only states 'Current UTC timestamp.' It does not explain how the parameters relate to the tool, what format the timestamp uses, or why the parameters exist. This is severely incomplete for making a well-informed 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 schema already documents all parameters. The description adds no parameter-level meaning beyond that. Baseline of 3 is appropriate because the schema handles the heavy lifting, even though the description fails to clarify that parameters are likely irrelevant to the tool's core function.

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

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

The description clearly identifies the tool's output as the current UTC timestamp, which is specific and understandable. It lacks a verb but is not tautological. It does not explicitly distinguish itself from related siblings like timezone or iana-zones.

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

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

No guidance is given about when to use this tool versus alternatives such as timezone or other time-related tools. There are no exclusions, prerequisites, or context hints. The agent must infer usage entirely from the name and short phrase.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure. It does state 'The body is discarded,' which implies no state change, but it does not disclose the return format, error behavior when JSON is invalid, or which input parameter is actually consumed—especially since the schema contains many seemingly unrelated fields.

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 the purpose: 'Check whether a body is valid JSON.' The second sentence provides useful behavioral information about discarding the body. It is concise, though the ambiguity of 'body' prevents top marks for clarity.

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

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

The tool has seven parameters and no output schema, yet the description leaves it unclear which parameter to supply and what the tool returns (e.g., boolean, error). Given the sibling list of shape-check tools, the description should specify that only the `json` parameter matters and clarify the validation result semantics; these gaps make it 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?

The input schema has 100% description coverage across all seven parameters, so the baseline is 3. The description adds no additional parameter-level meaning; it only says 'body' without connecting it to the `json` field, and the schema already explains that `json` is 'JSON text to validate; discarded after the 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 the core operation ('Check whether a body is valid JSON') with a specific verb and resource, and this clearly distinguishes it from sibling shape-check tools like domain-shape or github-repo-shape. However, the term 'body' is ambiguous and does not explicitly map to one of the input schema's parameters, so it falls short of a perfect 5.

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

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

No guidance is provided about when to use validate-json versus the various sibling tools, and no alternatives or exclusions are mentioned. The agent would have to infer from the tool name and schema which shape-checking task it applies to.

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 explaining side effects, network usage, or read-only behavior. It implies a read-only weather lookup but does not explicitly disclose that it makes an external API call or that all other parameters are ignored.

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

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

The description is a single, short sentence that conveys the core functionality without any fluff. It is appropriately sized and front-loaded with the main action.

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

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

The description lacks any output schema, usage examples, or instructions on which parameter is required. Given the confusing schema with many discarded parameters, an agent has no way to know how to correctly 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?

The schema includes nine parameters, all optional, with descriptions that are largely irrelevant or contradictory to the tool's purpose. For example, the 'city' parameter is described as 'discarded after the call,' which directly conflicts with the tool's stated function. The descriptions provide no useful guidance for selecting or filling parameters.

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

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

The description clearly states the tool returns the current temperature for a city using Open-Meteo, which is a specific verb and resource. However, it does not distinguish this from sibling tools or mention any alternative, so it loses one point for lack of 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 gives no guidance on when to use this tool versus any sibling tool. There is no mention of prerequisites, alternatives, or situations where this tool is preferred.

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

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

With no annotations present, the description carries the behavioral disclosure burden. It does disclose that the body is discarded and scopes to public URLs, which is useful. However, it omits redirects, error behavior, rate limits, and the fact that many schema parameters are likewise discarded.

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

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

Two short sentences, front-loaded with the core purpose and the key behavioral note. Every word earns its place with no redundancy or fluff.

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

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

The tool has a confusingly broad input schema with many unrelated parameters, no output schema, and a description covering only the URL use case. It doesn't clarify whether the parameters are independent modes or which one to pass for the described behavior, leaving an agent without enough context to call it correctly.

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

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

All schema properties have individual descriptions, so schema coverage is 100%, warranting the baseline of 3. The tool description adds no parameter-level meaning beyond restating 'public URL,' and it fails to reconcile the many unrelated parameters (ref, city, feed, json, path) with 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 clearly states the tool reports HTTP status and content type for a public URL and that the body is discarded. This identifies the resource and output distinctly, though it lacks an explicit verb and doesn't differentiate from similar siblings like fetch-status.

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

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

The description offers no when-to-use guidance or alternatives. It only notes 'public URL' as a constraint, but does not explain when to choose this tool over fetch-status, normalize-url, or browser-url-ok. An agent must infer usage from the name.

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

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

The description adds a privacy-relevant behavioral note that the title is 'discarded after the call,' but no annotations exist to cover side effects, return behavior, or failure modes. It also references a 'title' that does not actually appear as a parameter in the input schema, weakening the behavioral clarity.

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

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

The description is short and front-loaded, with no wasted words. However, it is under-specified for a tool with seven parameters and no output schema, so the brevity comes at the cost of completeness.

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

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

Given the seven-parameter schema, no output schema, and no annotations, this description is far too thin. It omits the critical title-to-parameter mapping, return type, error behavior, and usage context, so an agent cannot reliably select or invoke the tool.

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

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

The description does not explain how any of the seven schema parameters relate to the 'Wikipedia title' being checked. The word 'title' is absent from the input schema, so an agent cannot determine which parameter supplies the title or how the other unrelated-looking parameters are used.

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

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

The description states a specific verb and resource: 'Check whether a Wikipedia title exists.' This clearly identifies the tool's core purpose and distinguishes it from URL-shape or fetch-status siblings. However, it does not explicitly describe the return value or differentiate among siblings that might also handle Wikipedia-related checks.

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

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

The description gives no guidance about when to use this tool versus other shape-check or status-check tools in the sibling list, nor when not to use it. The intended use case is only implied by the tool name and the single stated purpose.

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