America/Montevideo clock

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

With no annotations, the description carries the full burden. It adds a useful behavioral detail—"Task text discarded"—and lists what the tool returns. However, it does not state whether the operation is read-only, requires authentication, or has side effects, which is a moderate gap for a lookup tool.

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

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

The description is two sentences with no wasted words. It front-loads the primary purpose, then names the outputs and an important discard behavior. Every phrase earns its place.

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

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

For a simple lookup, the description names the returned artifacts and flags that task text is ignored. But with six optional-looking parameters and no output schema or annotations, it does not explain how the parameters relate to the lookup or when to invoke it, leaving room for misinterpretation.

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 already documents all six parameters (100% coverage), so the baseline is 3. The description adds no parameter-level meaning beyond saying task text is discarded, which does not map to any schema property. It does not compensate for or improve upon 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?

States the specific verb "Find" and a specific resource: "public pay-per-call tool gateway (Monid)". It lists concrete returns—CLI setup, how-it-works, skill file, and remote MCP hops—which clearly separates it from sibling tools focused on URLs, validation, and timing.

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 about when to use this tool versus the many sibling tools such as web-fetch, normalize-url, or fetch-status. The purpose is implied, but the description gives no explicit conditions, exclusions, or alternative recommendations.

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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds the useful clarification that no browser is launched, but it does not describe what network operation actually occurs, timeouts, or the nature of the returned result, leaving a modest behavioral 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 one short sentence with no filler. It front-loads the primary action and immediately adds the important negative behavior, which is exactly the structure a tool description should follow.

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 seven loosely related parameters, no required fields, no output schema, and several similar sibling tools, this description is too thin. An agent cannot tell which parameter to supply, whether the parameters are alternatives or combined, or what exactly the tool returns, so the contextual 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?

Schema coverage is high; every parameter has a description, so the schema carries the semantic weight. The tool description itself adds no parameter-level meaning and does not clarify how the many heterogeneous parameters relate to the stated URL check, so a baseline 3 is appropriate.

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

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

The description states a concrete check ('whether a URL can be opened') and adds a key negative fact ('No browser is launched') that distinguishes it from sibling tools like playwright-url-ok. However, the stated resource scope is narrower than the input schema, which accepts city, feed, host, json, path, and ref, so the description does not fully capture what the tool actually validates.

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

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

No explicit guidance is given about when to prefer this tool over alternatives such as web-fetch, fetch-status, normalize-url, or playwright-url-ok. 'No browser is launched' implies a lightweight reachability check, but it never names alternatives or states the conditions that select this tool.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the expression is 'discarded,' which hints at not retaining input, but it does not state whether the result is returned, whether there are side effects, what happens for invalid expressions, or any safety-relevant 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, with the core action in the first sentence. However, it is under-specified: 'Expression discarded' raises more questions than it answers, and the absence of parameter mapping makes the brevity a liability rather than a strength.

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

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

For a tool with seven string parameters, no annotation coverage, and no output schema, this description is far too incomplete. It does not explain how any schema field relates to arithmetic evaluation, what the tool returns, or how to construct a valid call, so an agent cannot reliably invoke it.

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

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

The input schema richly describes its seven parameters, but none of them obviously corresponds to an arithmetic expression. The description introduces 'a+b style arithmetic' without mapping it to any schema field, leaving the agent unable to determine which parameter should contain the expression. This is a critical semantic gap 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 action ('Evaluate') and a specific resource ('a+b style arithmetic'), making the tool's core purpose clear. It also implicitly differentiates from the sibling validation/shape-check tools, none of which are arithmetic evaluators.

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 calc-eval instead of siblings, no example invocation, and no mention of prerequisites or alternatives. The only usable instruction is the action itself, which is not enough to choose between tools 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?

There are no annotations to rely on, so the description carries the burden. It does disclose one useful behavioral fact ('Page content is not stored'), but it omits other important behaviors: that most of the parameters are explicitly discarded, how URL lookup or status checking behaves, and whether the tool has side effects beyond the lookup.

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 behavior is front-loaded and the storage-disclosure sentence earns its place. It is appropriately sized for the amount of signal it provides, even though other aspects of the tool definition are sparse.

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

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

Given the tool's overloaded schema with eight parameters, a large sibling group of URL and status tools, and no output schema, the description is not complete enough for confident invocation. It never states which parameter is the required input, what the return shape looks like, or how this tool relates to the many nearby 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?

The input schema already provides descriptions for all parameters, including explicit discard notes, so the description does not need to repeat them. The description adds only a top-level focus on 'a URL', which helps connect the schema's many parameters to the intended use but does not meaningfully extend the per-parameter explanations.

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 output ('host, scheme, and HTTP status') and the target resource ('a URL'), which gives an agent a concrete model of what the tool does. However, it does not differentiate itself from sibling tools like fetch-status or normalize-url that could plausibly return similar information, and the tool name 'citation' is not self-explanatory.

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 instead of alternatives such as web-fetch, fetch-status, or normalize-url. The note that 'Page content is not stored' hints at a privacy-related use case, but there is no explicit when-to-use or when-not-to-use 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 annotations = None, the description carries the full disclosure burden. It adds one genuine tool-level trait, 'No identifiers are retained', which is a meaningful privacy statement, though it partly echoes the schema's per-parameter 'discarded after the check' notes. It does not disclose return format, whether classification is local and synchronous, error behavior, or external-call 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?

Two sentences with zero filler; the purpose is front-loaded and the privacy note follows. Each sentence earns its place. The terseness borders on under-specification for an 8-parameter router, but judged purely as conciseness and structure, it is efficient and well-ordered.

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 8 heterogeneous parameters, no annotations, and no output schema, yet the description explains neither the classification output, the input contract (e.g., exactly one argument expected), nor how it relates to the 27 siblings. The richly described schema parameters only partially compensate for the missing tool-level context.

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

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

Schema coverage is high: all 8 parameters (ref, url, city, feed, host, json, path, search) have individual descriptions, so the baseline is 3. The tool description itself adds no parameter-level meaning and never clarifies whether the parameters are mutually exclusive single inputs rather than combinable fields, which is a notable gap for a classifier.

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

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

The description states a verb and resource ('Show how this request is classified'), so it is not a tautology, but 'classified' is left abstract — no classification taxonomy or output category space is named. Among 27 shape-check siblings, nothing in the description differentiates this tool as the routing/dispatch entry point except the generic phrasing.

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 guidance on when to use this tool versus alternatives like domain-shape, validate-json, or normalize-url. Neither conditions for use, exclusions, nor the intended 'call this first to determine the input category' workflow are stated, so an agent must infer usage from the 8 heterogeneous parameters.

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

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

The description discloses that the tool is a pure label-splitting operation and explicitly excludes WHOIS/ownership enrichment, which is useful behavioral context. However, with no annotations present, it stays silent on return format, error behavior, and side effects, leaving the agent to infer them.

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 phrase adds information. The core action and a key exclusion are communicated 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?

For a 7-parameter tool with no output schema and no annotations, the description doesn't specify which parameter is the hostname input, what the returned labels look like, or how it differs from sibling shape tools. The likely 'host' parameter is inferable from the schema, but the overall operational contract 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?

Input schema provides descriptions for all seven parameters (100% coverage), so the description adds little; only 'host' is arguably linked by the phrase 'hostname.' The description doesn't clarify how the other parameters relate to the split, but the schema already labels them as discarded.

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

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

Description identifies a specific operation ('Split a hostname into labels') and a clear resource, and adds a scope exclusion ('without WHOIS or ownership data'). It doesn't name sibling tools, so differentiation is implicit rather than explicit.

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 alternatives are provided; the only nod is the negative qualifier 'without WHOIS or ownership data,' which suggests a limitation rather than a routing condition. Among many sibling shape tools, an agent gets no reason to choose this over figma-url-shape or github-repo-shape.

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

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

The description discloses that the tool performs a HEAD request and returns only a status, which is the main behavioral trait. However, it does not explain what happens with the many unrelated parameters or whether ignored inputs affect behavior, so transparency is only partial.

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

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

The main description is concise and front-loaded with the essential action and result. The parameter list is long and noisy, but the descriptive text itself is tightly written.

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 required parameters, and several seemingly irrelevant inputs, the description does not provide enough context to know how to call the tool correctly or what response shape to expect.

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 all 9 parameters have descriptions, most are clearly mismatched with the tool's stated purpose (e.g., 'city', 'json', 'zone'), and even the url description says 'normalize or cite' rather than 'fetch status'. This creates significant confusion about which parameters are meaningful.

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

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

The description clearly states a specific action ('HEAD a public URL') and output ('return status only'), making the tool's core purpose easy to understand. It stops short of naming sibling alternatives, but the 'status only' qualifier helps distinguish it from content-fetching 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 when the tool should be used (when only an HTTP status is needed via HEAD), but it does not explicitly discuss alternatives or provide decision guidance compared to siblings like web-fetch or browser-url-ok.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states that the path is discarded, but it does not disclose whether the tool validates, normalizes, returns parsed components, or has any side effects.

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

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

The description is very concise and front-loaded, but it is arguably too thin for a tool with 9 parameters and no output schema. It has no filler, but it omits necessary context.

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

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

Given the tool has 9 optional parameters, no output schema, and no annotations, the description is incomplete. It does not clarify which parameter should contain the Figma URL, what the tool returns, or how 'Path discarded' affects 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 baseline is 3. The tool description adds little to parameter understanding, and the schema contains many unrelated parameters, but the parameters themselves are individually described.

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 (Parse) and a specific resource (Figma file URL), which distinguishes it from sibling URL tools like normalize-url and domain-shape. The phrase 'Path discarded' adds a behavioral detail, though it is terse and not fully explained.

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 instead of alternatives such as browser-url-ok, normalize-url, or web-fetch. No exclusions or conditions of use 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?

The description adds a meaningful behavioral trait: 'No disk access.' This clarifies that the tool is a non-destructive, in-memory shape check. However, it does not disclose whether it returns a boolean, throws errors on invalid input, or silently discards the non-path parameters, and no annotations are provided to fill that gap.

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

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

The description is extremely concise and front-loaded, with no redundant words. 'No disk access' earns its place by immediately setting expectations about side effects. It could arguably be more informative, but it does not waste any space.

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, no output schema, and no annotations, but the description only addresses 'path.' An agent cannot tell which parameter to supply for which goal or what the return value looks like. The multimodality implied by the schema is unresolved, making the description incomplete for correct invocation.

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

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

All seven parameters have descriptions in the schema, so schema_description_coverage is high. The description itself adds no parameter-level meaning, but with the schema already documenting each field, the baseline of 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 states a specific action ('check whether a path looks safe') with a clear resource (path) and quickly distinguishes it from disk access. However, the input schema lists six unrelated parameters (ref, url, city, feed, host, json), which makes the tool's exact scope less crisp than it could be.

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

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

No guidance is given about when to use this tool versus alternatives like wiki-title-ok, browser-url-ok, or domain-shape. The only contextual hint is 'No disk access,' which implies a pure format check but does not name any sibling or exclusion condition.

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 reveals the external dependency on Open-Meteo but does not mention network behavior, failure modes, rate limits, caching, whether the operation is read-only, or the returned coordinate format. This is minimal disclosure for a tool making an external call.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. It is efficient, though slightly under-specified in a way that is better captured by the completeness dimension.

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 input parameters, no output schema, and no annotations, this description is insufficiently complete. An agent cannot determine which parameter to populate, what the response structure looks like, or how errors from Open-Meteo are surfaced.

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 parameters already have schema descriptions, so the baseline is 3. The tool description adds no parameter-level meaning, such as which parameter supplies the place name or how coordinates are represented. It stays generic at the resource 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 clearly indicates that the tool provides latitude and longitude for a place using Open-Meteo. It lacks an explicit verb and does not explicitly differentiate itself from sibling tools, but the coordinate output is specific enough to distinguish it from weather or URL-oriented 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 alternatives such as weather-hint or other siblings. The description gives no input requirements, exclusions, or conditions, leaving the selection decision entirely 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?

No annotations are provided, so the description carries the full behavioral burden. It only says 'parse' and does not disclose what happens to unrelated parameters, how invalid or non-GitHub URLs are handled, or what the exact output 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?

A single, front-loaded sentence with no wasted words. It communicates the tool's entire purpose 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 parameters are well-described and the operation is simple, but there is no output schema and no annotation coverage. The description implies the return value (owner/repo) but leaves output format, error cases, and sibling alternatives unspecified, so it is minimally adequate rather than complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value beyond the schema by tying the `url` parameter specifically to GitHub and naming the extraction target (owner/repo), which the schema's generic 'HTPS URL to normalize or cite' does not.

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'), resource ('owner and repo'), and source ('GitHub URL'). This clearly distinguishes it from sibling shape tools such as domain-shape, figma-url-shape, and jira-key-shape.

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

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

The phrase 'from a GitHub URL' gives a clear use context: invoke when you have a GitHub URL and need owner/repo. It does not name alternative tools or exclusion cases, so it stops short of a 5.

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 adds one behavioral trait—'Titles discarded'—which tells the agent that story titles will not be returned. However, it does not disclose the return format, network dependency, or what happens with the 9 optional 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 only two short sentences with no filler. It is front-loaded with the main purpose, and the second sentence provides an additional useful behavioral note. It is concise, though it could arguably be more structured for a tool with a large optional 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?

With 9 optional parameters, no output schema, and no annotations, the description is too thin to support confident invocation. It does not state which parameters to pass, whether any parameters are required for HN counting, or what the output looks like beyond implying that titles are excluded.

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 information. The schema descriptions individually explain each parameter, but the description does not clarify which parameters are relevant to the HN-counting behavior or whether they are all 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 a specific action ('Count') and a specific resource ('current Hacker News front-page stories'), which makes the tool's purpose immediately understandable. It doesn't explicitly distinguish from siblings, but no sibling appears to offer the same HN-focused function.

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 context for use is clear: call this tool when you need a count of current Hacker News front-page stories. It doesn't list exclusions or alternatives, but the purpose is specific enough that an agent can infer when to select it.

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

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

No annotations are provided, so the description carries the full burden. It fails to state any behavior, side effects, return values, or discard semantics; the only behavioral details live in the schema parameter descriptions and are disconnected from the description's timezone 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?

This is under-specification, not successful conciseness. The one-phrase description has no verb, no scope, and no useful detail, making it closer to a placeholder than a deliberately minimal tool definition.

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 a description that doesn't connect the parameters or return value to timezone names, the tool is effectively opaque. An agent cannot know what to pass in or what to expect from the 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?

All parameters have rich schema descriptions, so the baseline is 3, but the tool description contributes nothing about parameter semantics. Worse, the parameters appear entirely unrelated to the stated timezone functionality, leaving an agent confused about why these fields exist.

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

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

The description is a noun phrase, 'Common IANA timezone names for clock calls,' with no verb indicating what the tool does. It doesn't specify whether it returns names, validates them, or serves some other function, and it doesn't distinguish this tool from siblings like timezone or utc-time.

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

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

The description gives no guidance on when to use this tool versus alternatives. It not only lacks context or exclusions, but its stated purpose is contradicted by the schema, which contains parameters like ref, url, json, and path that have nothing to do with IANA timezone names.

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 does disclose one useful trait: the key is discarded rather than retained or echoed. However, it does not describe the return value, error behavior, or what happens for an invalid shape, leaving a meaningful 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?

Two short sentences with no filler, and the main action is front-loaded. The 'Key discarded' sentence earns its place as a behavioral warning without adding unnecessary length.

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

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

For a tool with no annotations and no output schema, the description omits essential operating details: what the result looks like, whether invalid keys error or return false, and the exact validation rule. The schema provides some support, but an agent still lacks enough context to confidently interpret the tool's behavior.

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

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

The schema already documents all parameters with descriptions and provides an example format for issue_key, so description coverage is high. The description adds only the discarded-key lifecycle note, but does not explicitly map the tool to the issue_key parameter or refine its accepted format.

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.' This clearly separates it from sibling shape validators like github-repo-shape or wiki-title-ok. The only ambiguity is what 'shape' exactly means, but the issue_key schema example (PROJ-123) fills that gap.

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 alternatives, no 'use when' conditions, and no exclusions. An agent can infer it is for validating Jira issue keys from the name and issue_key property, but the description never explicitly says so.

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

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

The description does disclose that the body is discarded, and the schema indicates several parameters are discarded after shape checks. However, with no annotations present, the description carries the full burden of behavioral disclosure; it does not explain what 'hint' means, whether redirects are followed, how status codes are determined, or what happens for non-library URLs.

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

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

The description is a single, front-loaded sentence with no wasted words. It states the primary action first and adds the body-discard trait efficiently, though it is arguably too sparse for a tool with seven parameters.

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

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

Given the seven parameters, lack of an output schema, and absence of annotations, this one-sentence description is grossly incomplete. An agent cannot infer the full behavior, the purpose of the city/feed/json/path parameters, or the conditions under which this tool should be invoked.

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 parameters in the schema have descriptions, so schema coverage is high. The main description adds no parameter-level meaning beyond what the schema already provides, and it does not clarify how the various parameter types relate to the stated 'public library docs URL' 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 ('HTTP status') and a resource ('public library docs URL'), which provides a clear core intent. However, the input schema accepts seven diverse parameters (ref, url, city, feed, host, json, path), so the stated purpose is narrower than the actual tool scope and it does not distinguish this from sibling tools like fetch-status or web-fetch.

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 similar alternatives. The description only states what the tool does, with no exclusions, prerequisites, or mention of alternative tools.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It does disclose that values are discarded, but it omits what the count represents (top-level vs nested keys), whether the input must be valid JSON, what is returned, and whether there are side effects. The one disclosed trait is useful but far from sufficient for an unannotated tool.

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

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

Two short sentences are front-loaded and contain no filler. The description is efficient, but it is so brief that it leaves the parameter mapping and return behavior entirely to the schema, so it does not earn a 5.

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

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

With no annotations, no output schema, and nine optional parameters, the description is materially incomplete. It does not state which parameter supplies the JSON object, whether the tool can run with no arguments, or what the caller receives after the count. An agent would have to guess the invocation contract.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning beyond the schema; notably, it never identifies 'json' as the parameter containing the object to count, even though the schema describes it as text to validate. It neither lowers nor raises the baseline.

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

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

The description states a concrete action ('Count keys') on a specific resource ('a JSON object') and adds a distinct behavioral note that values are discarded, which separates it from validation-type siblings. It does not differentiate against sibling tools like validate-json or reference the relevant 'json' 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?

There is no guidance on when to choose this tool over validate-json, domain-shape, or other shape/check siblings, and no exclusions such as 'use X when you need values'. The only implication is that values are not retained, but no explicit alternative is given.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose that no browser is launched, which is useful, but it does not say whether a network request is made, what 'opened' means, or whether the operation has side effects or prerequisites.

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 'No browser is launched' caveat earns its place as a behavioral qualifier. It is appropriately concise, though it sacrifices 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?

For a tool with nine parameters, no output schema, and competing siblings, the description is too sparse. It does not state the return value or success criterion, explain which parameter is the primary input, or address the unrelated-looking parameters (city, feed, json, path), leaving an agent with an incomplete picture.

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 high-coverage baseline applies and the description need not repeat parameter details. It adds no parameter-level meaning, and some schema descriptions (e.g., url as 'normalize or cite') sit oddly with the stated purpose, but the schema itself already documents all nine 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 identifies the resource (a URL), which is enough to distinguish it from many siblings. The qualifier 'No browser is launched' helps separate it from browser-based tools, though the criterion for 'can be opened' is left 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?

The description provides no explicit when-to-use or when-not-to-use guidance. It never names browser-url-ok, fetch-status, or web-fetch, nor says to prefer this tool when avoiding a browser launch, so an agent must infer the intended use case from the tool name and the negative statement.

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

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

No annotations are present, so the description carries the full behavioral disclosure burden. It only says 'Query discarded,' which partly duplicates the existing schema note on `q`, and it fails to state what the tool returns (e.g., a numeric character count) or how it handles missing or invalid input.

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

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

The description is compact and front-loaded with the main operation in the first sentence. The second sentence is brief and adds a privacy-relevant note, though it is somewhat redundant with the schema's note that `q` is discarded.

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

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

For a tool with no output schema and no annotations, the description should specify the expected return value, the relevant input parameter, and when to use it among many siblings. The current text covers none of those, leaving an agent to infer too much from the schema alone.

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

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

The input schema documents every parameter with a description, so schema coverage is high and the baseline is 3. The description adds general semantic context by implying the target is the `q` field, but it does not explicitly name that parameter or clarify how the other schema fields relate.

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 an action ('Count characters') and a target resource ('a search query'), which matches the tool name and is distinct from sibling shape/validation tools. It could be stronger by explicitly naming the `q` parameter, but the core purpose is unambiguous.

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

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

There is no guidance on when to use this tool versus siblings like normalize-url, validate-json, or domain-shape. The description provides no context about the related 'shape check' tools or when counting query length would be the appropriate 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?

Annotations are absent, so the description carries the full burden of behavioral disclosure. It provides none: no indication of side effects, read-only nature, return value, or the fact that several inputs are discarded. The schema mentions discarding, but the description itself is silent.

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

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

The description is short, but its brevity comes from under-specification rather than deliberate concision. It is essentially a one-line restatement of the tool name and does not contain operational information worth front-loading.

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, no annotations, and no output schema, this description is far too thin. An agent cannot determine what inputs to provide, what the tool returns, or how to invoke it correctly based on the description alone.

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

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

The schema provides descriptions for all seven parameters, so baseline coverage is high and the description is not required to repeat them. However, the description adds no meaning about why these diverse parameters relate to a status-code catalog, so it cannot earn credit beyond the baseline.

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

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

The description is a noun phrase, 'Short catalog of common HTTP status codes,' which largely restates the tool name and lacks a verb or stated operation. It gives a subject area but does not explain what the tool does with any of its inputs or how it differs from similar tools 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?

No usage guidance is provided. The description does not specify when an agent should choose status-catalog over sibling tools, nor does it mention any 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, the description carries the transparency burden. It discloses one meaningful trait—the prompt is discarded—and implicitly promises a fixed template output. But it does not state whether all inputs are ignored, whether the template varies by arguments, or what errors/limits exist, so transparency is partial.

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

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

Two short declarative sentences carry the whole definition, with the main verb and object first. The second sentence earns its place by warning that input is ignored; 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?

For a trivial, stateless template tool, the definition covers the core return value and discard behavior. But without any output schema or richer description, an agent cannot know what the three steps are, whether any argument is required, or what the tool is actually for in a workflow, so completeness is adequate but not strong.

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

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

Every schema property has a description, giving high schema coverage, so the baseline is 3. The tool description adds no parameter-specific meaning; the 'discarded' message just echoes the schema's own 'discarded after...' notes. No compensation is needed, but none is provided either.

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 names the exact deliverable ('a three-step thinking template') and the action ('return'), making the tool's purpose recognizable and distinct from sibling fetch/validation/utility tools. The aside 'Prompt discarded' slightly muddies the purpose by implying the tool ignores user input, 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?

No when-to-use, prerequisites, or alternative selection guidance is provided. The description never mentions sibling tools such as citation, calc-eval, or validate-json, so an agent has no basis for choosing think-steps over them. 'Prompt discarded' hints that the prompt isn't processed, but doesn't explain when that behavior is desirable.

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 full behavioral disclosure burden. It does not mention that other input fields are discarded, that an external API call is made, or what the output includes beyond temperature. The main behavior is stated, but key operational traits are omitted.

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

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

One short, focused sentence with no filler or repetition. It is front-loaded with the essential fact and 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?

The schema contains eight parameters, most of which are marked as discarded, but the description does not state that city is the only meaningful input for this tool. Without this context, an agent selecting parameters could be misled. No output schema or annotations further compound the incompleteness.

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, including 'discarded after the call' semantics, so schema coverage is effectively 100%. The description adds little parameter-level meaning beyond implicitly tying 'city' to the tool, which is only a baseline contribution.

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 purpose: current temperature for a city, and identifies the data source (Open-Meteo). It is recognizable and distinct from sibling tools like geo-hint, though it lacks an explicit action verb such as 'returns' or 'gets'.

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 exclusions, and no mention that only the city parameter is relevant. The description simply identifies the provider without giving selection criteria.

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

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

With no annotations, the description carries the behavioral disclosure burden. It usefully reveals that the body is discarded and the URL is public, implying no auth. It does not mention redirects, error handling, timeouts, or rate limits, which could matter for a network-fetching tool.

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

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

Two short sentences with no filler. It is front-loaded with the core behavior and immediately adds the key limitation: 'Body discarded.' Every word earns its place.

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

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

The description states the output (HTTP status and content type) and a key behavioral detail, but it leaves sibling selection and the confusing optional-parameter surface unresolved. Given the 9-parameter schema and no output schema, a bit more context about the intended URL parameter would make it more complete.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the tool description adds no parameter-specific guidance. The description does not clarify which of the 9 optional parameters is the operative one, and several schema parameter descriptions seem unrelated to HTTP status/content-type checking.

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

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

The description clearly states what the tool does: it returns HTTP status and content type for a public URL. 'Body discarded' also separates it from content-retrieval tools, though it does not explicitly name sibling alternatives.

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: for lightweight status/content-type checks of public URLs, and not for fetching page content. However, it gives no explicit guidance about choosing it over siblings like fetch-status, 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?

Annotations are absent, so the description must carry the behavioral disclosure burden. It offers only the note that the title is discarded after the call, which is a useful privacy signal, but it says nothing about return type, side effects, network behavior, or required permissions.

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 wasted words, and the primary verb is front-loaded. The 'Title discarded after the call' clause is a deliberate transparency statement, not filler.

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

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

For a tool with no output schema, no annotations, and seven loosely defined parameters, this description is far too thin. It does not specify which parameter to use, what result to expect, or how this tool relates to sibling validation utilities, so an agent cannot 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?

The input schema covers all seven parameters with descriptions, but the description introduces 'Wikipedia title' while no parameter is named 'title' or described as a Wikipedia title. This mismatch creates confusion rather than adding meaning, so the agent cannot determine which parameter to populate.

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 ('Check') and resource ('Wikipedia title existence'), so the core action is identifiable. It does not, however, connect this action to any input parameter or distinguish it from sibling existence/shape checks such as file-path-ok or domain-shape.

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

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

No guidance is provided on when to use this tool instead of alternatives. The description does not name any sibling tool, give exclusion conditions, or indicate which parameter should carry the Wikipedia title.

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