ISO country CV

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

With no annotations provided, the description carries the full burden. It does disclose a significant behavioral trait via 'Task text discarded' and the per-parameter discard notes in the schema, and it lists what is returned. However, it does not disclose auth or cost implications implied by 'pay-per-call', failure behavior, or whether this is a read-only operation.

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?

Three short sentences, front-loaded with the core purpose, followed by return artifacts and the discard caveat. Each sentence earns its place and there is no filler, though 'Task text discarded' is slightly cryptic in isolation.

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

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

For a 9-parameter tool with no annotations and no output schema, the description names the return artifact types but leaves gaps: how the heterogeneous parameters relate to the tool's purpose, the exact response shape, and when to invoke it are all unstated. The thorough per-parameter schema descriptions partially compensate.

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 of 3 applies. Each of the 9 parameters is individually documented in the schema, including its discard behavior. The tool description itself adds no per-parameter meaning beyond what the schema already states.

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 ('Find a public pay-per-call tool gateway (Monid)') and lists the concrete artifacts it returns (CLI setup, how-it-works, skill file, remote MCP hops). It is distinguishable from the sibling utility tools, though the exact nature of 'Monid' and its relationship to the tool's name remain somewhat opaque.

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

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

No when-to-use guidance is provided anywhere in the description. It never states when an agent should call this tool versus alternatives like web-fetch, normalize-url, or validate-json, and offers no exclusions or conditions. The heterogeneous set of optional inputs (city, feed, json, zone) makes the intended invocation context even less obvious.

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

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

With no annotations, the description must carry behavioral disclosure, and it only states the negative side-effect 'No browser is launched.' It does not disclose whether a network request is made, whether the call is read-only, what 'can be opened' means, or what happens with the input values.

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 make the core purpose and a key constraint immediately visible with no filler. The structure is appropriate even though the description could be more informative.

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

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

For a tool with 9 optional parameters, no annotations, and no output schema, the description is too thin: it omits return shape, how to decide among the many possible inputs, and what 'can be opened' entails. The schema describes parameters, but the overall calling context 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?

The input schema has 100% description coverage and every parameter is individually documented, so the description does not need to repeat parameter meaning. It also adds no selection guidance for the 9 optional params, but that is not required under the high-coverage baseline.

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

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

The description names a specific action (check) and resource (URL) with an explicit outcome, and the second sentence adds a distinguishing trait: no browser is launched. It is clear enough to separate from playwright-url-ok, though it does not explicitly name 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?

There is no statement about when to reach for this tool versus siblings like playwright-url-ok, normalize-url, or fetch-status. The no-browser note hints at use cases, but no explicit guidance or exclusions are provided.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. 'Expression discarded' hints at non-retention but does not clarify side effects, persistence, access requirements, or return behavior, and it cannot be mapped to a real parameter. This is insufficient behavioral transparency.

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

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

At two short sentences it is not verbose, and the core action is front-loaded. However, 'Expression discarded' is vague and does not add usable structure, so the brevity shades 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, no annotations, nine optional parameters, and a description that fails to identify which parameter carries the expression, an agent cannot reliably select or populate the call. There is no statement of return values or validation behavior. This is inadequate for correct invocation.

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

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

Schema coverage is 100%, but the central concept in the description of an a+b expression has no corresponding property among the nine string parameters. The description adds no parameter mapping and could mislead an agent into looking for an arithmetic expression argument. This falls below the high-coverage baseline.

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

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

The phrase 'Evaluate a+b style arithmetic' states a specific verb and domain, and no sibling tool appears to handle arithmetic evaluation, so it is distinguishable. However, 'Expression discarded' muddies what is actually evaluated, and the schema provides no expression field, so clarity is incomplete.

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 sentence says when to use calc-eval versus any sibling tool, and there are no alternative references or exclusion conditions. The description only implies 'use for arithmetic' without explaining prerequisites or when not to use it.

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

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

With no annotations, the description carries the behavioral transparency burden. It adds one meaningful disclosure: 'Page content is not stored.' However, it does not mention whether a network request is made, how redirects or errors are handled, or what side effects, if any, occur. Some useful context is present, but important behavior remains undisclosed.

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

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

The description is two short sentences with the core function front-loaded and no filler. The second sentence adds a valuable privacy guarantee. Every sentence earns its place, and the structure makes the primary purpose immediately clear.

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 required parameters, no output schema, and no annotations, yet the description only addresses URL-related behavior. It does not specify output format, whether a parameter is required to get a result, or how this tool relates to its many siblings. For a tool with this schema complexity, the description 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 description coverage is 100%, so the baseline is 3. The description itself adds almost no parameter semantics beyond mentioning 'URL' and does not clarify that only the url parameter is relevant. The schema provides individual descriptions for all nine parameters, including notes that others are discarded, so the parameter meanings are documented elsewhere.

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

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

The description states a specific verb and resource: 'Return host, scheme, and HTTP status for a URL.' This clearly indicates what the tool does without needing the schema. However, it does not distinguish it from sibling tools like fetch-status or normalize-url, and the tool name 'citation' is not reflected in the described behavior.

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 a URL' gives a clear context: use this tool when you need host, scheme, and HTTP status from a URL. But it provides no guidance on when not to use it, names no alternatives such as fetch-status or web-fetch, and does not clarify how the other eight optional parameters relate to the URL-focused purpose.

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

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

With no annotations, the description carries the behavioral disclosure burden. 'No identifiers are retained' is a meaningful privacy guarantee and aligns with the schema descriptions that say inputs are discarded. However, it does not disclose return format, failure behavior, network/side effects, or whether multiple supplied parameters are allowed.

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 action is front-loaded, and the second sentence adds the key privacy behavior. Every word earns its place.

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

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

Despite having 9 optional parameters and no output schema, the description does not explain how to construct a valid request or interpret the resulting classification. The privacy statement is useful, but an agent would not know which parameters to provide, whether to provide them together, or what the response means.

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

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

Schema description coverage is 100%, and each parameter already has a clear explanation in the input schema. The description adds no parameter-specific meaning, but with full schema coverage that is acceptable; 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 uses a specific verb ('Show') and names the resource ('how this request is classified'), so it is not a tautology. However, 'classified' is vague: it never explains what classification categories or dimensions are involved, and it does less to distinguish the tool from siblings that validate or shape-check inputs.

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 rather than sibling tools such as validate-json, normalize-url, file-path-ok, or geo-hint. There are no examples, no exclusions, and no stated relationship to alternatives, so an agent cannot decide when this is the correct call.

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

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

There are no annotations, so the description carries the full burden. It tells the agent that the tool splits hostnames and does not return WHOIS/ownership data, but it does not disclose error behavior, network access, side effects, or handling of invalid hostnames. Significant behavioral detail is left unstated.

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

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

The description is a single front-loaded sentence with no filler. It names the action, the object, and a key exclusion, earning every word.

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

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

The tool has 9 optional parameters, no required parameters, no output schema, and no annotations. The one-sentence description does not explain why many unrelated parameters exist, how to choose among them, or what the tool returns. For a multi-parameter tool, this is under-specified.

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

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

All 9 parameters have full schema descriptions, so the schema already carries the parameter semantics. The tool description adds little beyond naming 'hostname', which aligns with the 'host' parameter, but it does not compensate for or add meaning 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 states a specific verb ('Split'), a specific resource ('a hostname'), and a clear boundary ('without WHOIS or ownership data'). This distinguishes it from enrichment or lookup tools and clearly conveys what the tool does.

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 action: split hostnames into labels. The phrase 'without WHOIS or ownership data' hints that this is not for ownership lookups, but no alternative sibling tools are named and no explicit when-to-use or when-not-to-use conditions are provided.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the HTTP method (HEAD) and that only status is returned, but it does not explain redirect handling, timeouts, error behavior, or whether the other eight schema fields are accepted and discarded. This is a minimal disclosure for a network-facing 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 a single efficient sentence with no filler, and the core action is front-loaded. It is easy to parse, though arguably too terse for a tool with nine optional schema parameters and no annotations.

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 complexity — nine optional parameters, no required parameters, no output schema, and no annotations — a one-sentence description about HEADing a URL is incomplete. The agent is not told which parameter to supply, what the returned status looks like, what happens with the other parameters, or how this tool relates to the large sibling set.

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

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

Schema description coverage is 100%, so the input schema already documents each of the nine parameters. The description adds no per-parameter meaning and does not indicate that `url` is the relevant parameter for this tool or how the other optional fields relate to fetch-status. The schema carries the parameter documentation burden, so the baseline score 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 concrete action ('HEAD a public URL') and output ('return status only'), which clearly distinguishes it from content-fetching tools like web-fetch. However, the input schema exposes eight other optional parameters, so the description does not clarify whether those are valid alternative inputs or simply ignored, limiting full purpose clarity.

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

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

The description implies when to use the tool: when an agent only needs the HTTP status of a public URL rather than page content. It provides no explicit alternatives, when-not-to-use guidance, or mention of sibling tools such as browser-url-ok or playwright-url-ok, and the broad optional schema leaves some ambiguity about which parameter should be supplied.

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 only that the path is discarded, but it does not explain whether this is read-only, what it returns, how malformed URLs are handled, or whether any network access occurs.

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

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

The description is short and front-loaded: the main action appears first, and the discarded-path trait is compact. It is concise, though the second clause is cryptic enough to lower its precision.

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

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

With nine optional parameters, no annotations, and no output schema, the description is under-specified. An agent cannot reliably determine which parameter to populate, what output to expect, or how this tool fits alongside the sibling URL and shape-checking tools.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no meaningful parameter guidance beyond the ambiguous 'Path discarded,' and it does not clarify that only the 'url' parameter is likely relevant among nine optional parameters.

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

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

The description names a specific verb and resource: 'Parse a Figma file URL.' This distinguishes it from other shape tools by domain. However, it does not state what the parsing produces or what makes a URL a valid Figma file URL, and 'Path discarded' is ambiguous between the URL path and the 'path' parameter.

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

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

There is no guidance about when to use this tool instead of siblings like normalize-url, github-repo-shape, domain-shape, or browser-url-ok. The Figma resource implies the intended domain, but no explicit alternatives or exclusions are provided.

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

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

The description clearly discloses one important behavioral trait: it performs no disk access. However, it does not define what 'safe' means, what the return value looks like, or how it handles invalid or unsafe paths. Since no annotations are provided, the description carries the full burden and only partially covers 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 with no wasted words. The main action and the key side-effect guarantee are front-loaded, making the description easy to parse quickly.

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

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

For an unannotated tool with no output schema and a cluttered parameter list, this is incomplete. It does not state the return type, the safety criteria checked, or which parameter should be supplied, leaving an agent to guess at important invocation details.

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

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

Schema description coverage is high, and the `path` parameter is documented as 'File path to check', so the core parameter is identifiable. However, the description itself adds no parameter-level guidance, and the schema's many unrelated optional parameters (url, city, feed, json) would benefit from an explicit note that only `path` is relevant.

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

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

The description states a specific verb ('Check'), a clear resource ('whether a path looks safe'), and an important constraint ('No disk access'). This distinguishes it from sibling validators like browser-url-ok and wiki-title-ok, making the tool's scope immediately identifiable.

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 disk access' phrase implies this is for static, side-effect-free path validation, but there is no explicit guidance on when to use this versus alternatives. No sibling tools or exclusion conditions are mentioned, so the usage context is only implied.

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

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

With no annotations supplied, the description must disclose behavior itself; it only mentions the Open-Meteo dependency and output type. It omits network calls, error behavior, rate limits, or that several schema fields are discarded, so an agent cannot predict 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 a single front-loaded sentence with no filler, naming both action and data source. It is concise, though it sacrifices substance needed for a 9-parameter 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?

A tool with 9 optional parameters, no required inputs, and no output schema needs a much richer description. The one-liner does not tell the agent which field to populate, what the response contains, or how the unrelated fields (ref, url, feed, json, path, etc.) relate to geo coordinates.

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; parameter descriptions are present and individually clear. The description adds no extra semantics and fails to map any parameter to the advertised 'place' lookup, but the schema already documents each field.

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 capability: returning latitude and longitude for a place via Open-Meteo. However, it does not identify which of the 9 optional schema parameters is the 'place' input, and it does not explain how it differs from sibling tools like weather-hint or timezone.

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 geo-hint versus alternatives, nor any exclusion criteria. The only clue is the generic purpose sentence, leaving the agent to infer that this is for coordinate lookups.

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 only says 'Parse owner and repo', but does not mention that many schema parameters are explicitly discarded, that the URL must be a GitHub HTTPS URL, or what the tool returns. Some parameter descriptions in the schema ('HTTPS URL to normalize or cite') also muddy the behavioral story.

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 direct sentence that front-loads the core purpose. It is concise and readable, but it omits important contextual information that would make it more useful.

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

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

This is a 9-parameter tool with no annotations and no output schema, yet the description is only one sentence. It does not explain which parameter to use, what the parse result looks like, or how the many 'discarded' parameters factor in. The missing output schema makes the lack of return-value description especially noticeable.

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

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

Schema description coverage is 100%, so the baseline is 3 and the description does not need to repeat parameter details. However, the description only relates to the 'url' parameter, leaving the other eight parameters' roles unclear in the context of github-repo-shape. The schema descriptions help individually, but the tool description adds no semantic guidance beyond them.

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

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

The description uses a specific verb ('Parse') and a specific resource ('owner and repo from a GitHub URL'), which distinguishes it from generic URL tools like normalize-url and other shape tools. It loses a point because it does not specify the output format or how the broad input schema relates to this parsing purpose.

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

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

The description gives no guidance on when to use this tool versus siblings such as figma-url-shape, jira-key-shape, normalize-url, or browser-url-ok. The only implicit usage signal is 'GitHub URL', but no exclusions, prerequisites, or alternative-selection criteria are provided.

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

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

With no annotations provided, the description carries the behavioral transparency burden. 'Titles discarded' is a useful behavioral disclosure, telling the agent not to expect story titles in the result. However, it does not mention return value format, network behavior, rate limits, or whether any input parameters affect the outcome.

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 and front-loads the core purpose immediately. There is no filler or redundant restatement of the tool name.

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

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

Given nine optional parameters, no annotations, and no output schema, the description is too sparse. It does not explain why the parameters exist, whether they are all ignored, what the tool returns, or how the count relates to any supplied URL or feed. An agent could call the tool but would have weak guidance on invocation 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?

Schema description coverage is 100%, so the baseline is 3. The description adds essentially no parameter-level meaning beyond what the schema already states about parameters being discarded. 'Titles discarded' is the only overlap, and it does not materially clarify the nine optional parameters.

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

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

The description states a specific action and resource: count the current Hacker News front-page stories. This clearly distinguishes it from sibling tools like web-fetch or fetch-status, which would retrieve or check status rather than return a count.

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 usage is implied by the action: use this when the agent needs the number of current Hacker News front-page stories. However, it does not explicitly mention when not to use it, nor does it name any alternative tools or conditions for choosing between them.

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

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

With no annotations at all, the description carries the full burden of behavioral disclosure, and seven words do not carry it. It does not state whether the tool is read-only, whether it performs network calls, what it returns, or how the 'discarded after the shape check' behavior hinted at in the schema works. The schema descriptions allude to side-effect-free discarding, but the tool 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?

Seven words with no filler, but this is under-specification rather than genuine conciseness: it omits the verb, the return value, and the relationship among nine parameters. A description this short cannot be 'appropriately sized' for a tool of this complexity, so brevity comes at the cost of meaning.

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

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

Even with a fully documented schema, the description leaves the central question unanswered: what does calling iana-zones do and what does it return? With no annotations and no output schema, nothing compensates for the missing operational description, and the relationship to the sibling time tools (timezone, utc-time) is unstated.

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

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

Schema description coverage is 100%, so the baseline is 3; each parameter is individually documented in the schema. However, the description does not explain why json, feed, host, and city would all be inputs to a tool about IANA timezone names, leaving the unifying semantics to inference. It meets the baseline but adds no parameter-level insight.

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

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

The phrase names a resource (IANA timezone names) and a context (clock calls) but contains no verb, so the actual operation is unclear. The nine heterogeneous parameters (json, feed, host, city, ref) suggest the tool derives or validates timezones from many input types, yet the description never reveals this. It is not a tautology, but it is vague about what calling it actually does.

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 only usage signal is 'for clock calls,' which implies a context but never explains when to prefer this tool over the sibling tools timezone or utc-time. There is no when-to-use guidance, no exclusions, and no mention of alternatives, so an agent gets almost no routing help.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. It states the tool fetches a public robots.txt and returns only group counts, but does not disclose how the 9 parameters are used, which ones are required, or what happens on failure. The parameter descriptions mentioning 'discarded after the shape check' suggest a conflicting behavior, undermining trust.

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

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

The description is a single concise sentence with no wasted words, but it omits essential information about parameter usage and output format. Conciseness is achieved at the expense 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?

For a tool with 9 parameters and no output schema, a one-sentence description is grossly insufficient. The agent lacks any information about the return structure, required inputs, or how to specify the robots.txt target, making successful invocation unlikely.

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

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

Although schema coverage is 100%, the parameter descriptions appear generic and unrelated to robots.txt (e.g., 'City name for a public weather hint', 'JSON text to validate'). The tool description adds no explanation of which parameter corresponds to the robots.txt URL or host, so the agent cannot reliably map inputs to the intended operation.

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

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

The description explicitly states the action ('Fetch a public robots.txt') and the scope of the result ('return group counts only'), which clearly differentiates it from generic fetch tools. However, it does not specify which input parameter identifies the target robots.txt, slightly reducing clarity.

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

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

The description gives no guidance on when to use this tool versus alternatives like web-fetch or fetch-status. There are no usage conditions, prerequisites, or exclusions, leaving the agent to infer applicability solely from the tool name.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the key is discarded, giving a useful privacy/retention trait, but it does not explain what happens for invalid keys, what the result looks like, or whether any other side effects occur.

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

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

Two short sentences with no filler. The operation is front-loaded and the discard note earns its place by adding behavioral context beyond the name.

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

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

A shape-check tool with a large, heterogeneous input schema and no output schema; the description omits which parameter to pass, the validation rules, and the return behavior. This is not enough for an agent to confidently 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 schema has seven individually described properties, giving a high baseline, but the description never maps 'Jira issue key' to any specific parameter such as ref or url. This ambiguity makes the correct parameterization unclear despite the schema-level descriptions.

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?

Names the specific operation—checking a Jira issue key's shape—and the tool name clearly separates it from sibling shape tools like domain-shape or figma-url-shape. However, it never states which schema field contains the key or what a valid shape is, so it is clear but under-specified.

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 any sibling validation or shape-check tool. It does not mention alternatives, exclusions, or the intended input scenario, so an agent must infer usage from the name alone.

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

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

With no annotations, the description carries the behavioral burden. It usefully discloses that the body is discarded and only the HTTP status is relevant. However, it does not mention whether a network request is made, whether redirects are followed, whether authentication is needed, or what the exact result shape is.

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

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

The description is a single sentence with no filler and the key behavioral point ('Body discarded') is front-loaded. It is easy to parse, though the brevity sacrifices useful usage and parameter guidance.

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

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

Given no annotations, no output schema, nine parameters, and many sibling tools, this description is incomplete. It omits the response format, which parameter should be populated, and how this tool differs from the other URL-status and hint tools.

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

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

Schema coverage is 100%, so the individual parameter descriptions exist and the baseline is 3. The description adds little parameter-level meaning and only references a 'docs URL,' while the schema includes many other parameter families such as city, feed, json, and path. It does not clarify whether those are usable by 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 concrete function: reporting the HTTP status of a public library docs URL, and adds that the body is discarded. This is clear at a glance, but it does not distinguish the tool from siblings such as fetch-status or browser-url-ok, and the schema exposes many unrelated parameters that the description never reconciles.

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 like fetch-status, browser-url-ok, or normalize-url. The description also does not state which of the nine schema parameters should be supplied, so an agent is left without 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?

No annotations are present, so the description carries the full burden. It mentions 'Values discarded' but does not clarify whether the operation is read-only, modifies state, or has side effects. The lack of explicit side-effect disclosure reduces transparency.

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

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

The description is brief and to the point, using only one sentence. It avoids unnecessary verbosity, but the extreme brevity omits critical details, so it is efficient yet slightly 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?

Given the tool has 9 parameters, none required, and no output schema, the description is severely incomplete. It fails to explain how to invoke the tool, what output to expect, or how parameters relate to the operation, leaving the agent without sufficient context to use 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?

Although schema coverage is 100%, the parameter descriptions are mismatched with the tool's purpose. For instance, the 'json' parameter is described as 'JSON text to validate' rather than for counting keys, and no parameter is identified as the primary input. This makes it unclear which parameter the description refers to.

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

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

The description clearly states the action 'Count keys in a JSON object' and the context 'Values discarded,' which distinguishes it from validation or other operations. However, it does not specify which input parameter contains the JSON object, slightly reducing clarity.

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

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

No guidance is provided on when to use this tool versus alternatives. The description gives no context for selecting it over sibling tools like validate-json or search-query-len.

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 is transparent that the operation is a read-only normalization and explicitly discloses that query and fragment are dropped from the result. It does not discuss error behavior or return structure, but for a simple normalization tool the key behavior is disclosed.

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

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

The description is two short sentences with no filler. The core purpose is front-loaded and the second sentence adds the only necessary behavioral qualifier.

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

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

Given no annotations and no output schema, the description is fairly complete: it names the returned components and the excluded parts. The main gap is that it never directly says only the url parameter is relevant, and the noisy nine-parameter schema could make that ambiguity matter, but the schema descriptions mitigate 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 schema already provides 100% parameter descriptions, so the baseline is a 3. The description adds meaning by singling out the URL as the input and by clarifying how its query/fragment are handled. It does not explicitly tell the agent to ignore the other eight parameters, but the schema's 'discarded' wording covers that.

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

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

The description uses a specific verb ('Return') and a specific resource ('origin, host, and path for a URL'), and it names the behavioral nuance that query and fragment are dropped. This clearly distinguishes normalize-url from sibling URL tools such as browser-url-ok, web-fetch, and figma-url-shape.

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

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

The description implies when to use the tool: whenever the agent needs normalized URL origin, host, or path. However, it does not explicitly mention alternatives or conditions when another tool should be used instead, so the usage guidance remains implicit rather than explicit.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It discloses one useful trait (no browser is launched), but it omits important behaviors: whether it performs a network request, what side effects occur, whether a URL must be absolute, what success/failure looks like, and why so many unrelated parameters are accepted and discarded.

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

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

The description is extremely concise and front-loaded: first sentence states the purpose, second adds a key behavioral constraint. No filler or repetition exists. However, the brevity is also why other dimensions suffer; the definition is clean but not informative enough.

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

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

Given 9 parameters, no annotations, no output schema, and many similar sibling tools, this description is far from complete. It does not explain return values, how to determine success, which parameters are relevant, or what 'can be opened' means operationally. An agent would struggle to call this tool correctly and confidently.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself adds no parameter semantics beyond 'URL' and does not explain how the other accepted parameters (city, feed, json, zone, query, etc.) relate to the check. The schema descriptions compensate, but the tool description fails to clarify which parameters are actually meaningful for the stated purpose.

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

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

The description states a clear action ('Check whether a URL can be opened') and a distinguishing behavioral note ('No browser is launched'). However, it does not clarify what 'opened' means in practice (HTTP fetch, DNS check, or something else), and it does not differentiate from siblings like browser-url-ok or fetch-status beyond the browser 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 on when to use this tool versus alternatives such as browser-url-ok, fetch-status, or normalize-url. The 'No browser is launched' note implies a difference from browser-based checks, but it never explicitly states the intended use case or conditions for choosing 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?

With no annotations, the description carries the full burden of behavioral disclosure. The explicit 'Query discarded' is a useful disclosure that the input is not retained or used beyond the length count. However, the description omits the return shape and does not explain whether the other eight supplied parameters are ignored or have any effect.

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 primary action front-loaded. The minimalism is efficient, though it borders on under-specification given the complexity of a nine-parameter 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?

Despite full schema descriptions, the definition leaves important invocation context missing: nine optional parameters, no required parameters, no output schema, and no statement about which parameter is the search query. An agent cannot confidently determine whether to pass only `query` or whether other fields are needed.

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

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

Schema description coverage is 100%, so the baseline is 3; each parameter already has a meaningful description. The tool description adds no parameter-level information beyond the phrase 'search query', which maps naturally to the `query` parameter in the schema.

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

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

The description states a concrete operation ('Count characters') on a specific resource ('a search query'), so an agent can distinguish it from sibling shape/status checkers. However, it does not explicitly identify the `query` parameter or the return value, and it does not differentiate against a same-purpose sibling, so it is not 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, and no exclusions or sibling tool names are mentioned. The agent can only infer the intended use case from the tool name and the generic verb.

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 does not state what happens when invoked, whether inputs are required, whether the operation is read-only, or what the output looks like. 'Short catalog' implies a static reference but is not a behavior.

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

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

The text is short and front-loaded, but it is under-specified rather than concisely complete: a single noun phrase with no structure to guide invocation or clarify which of the eight parameters to use. It is more of a label than a 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?

The tool has eight parameters, no output schema, and no annotations, yet the description gives no information about return values, input selection, side effects, or relation to sibling tools. As a result the definition is inadequate for an agent 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?

The schema provides descriptions for all eight parameters (ref, url, city, feed, host, json, path), so schema coverage is high and the baseline is 3. The tool description adds no parameter meaning, and the parameters' stated purposes (e.g., 'discarded after the shape check') are not connected to the HTTP status catalog, which is confusing, but the schema itself is not undocumented.

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 'Short catalog of common HTTP status codes' is essentially a restatement of the tool name with minimal elaboration; it uses a noun ('catalog') rather than a specific verb and does not distinguish this from siblings like fetch-status. An agent learns the general domain but not the precise action or how the catalog relates to the many input parameters.

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

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

There is no guidance about when to use this tool instead of fetch-status, normalize-url, or any sibling. The description neither states a use case nor names exclusions/alternatives, leaving the agent to guess.

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 the input prompt is discarded and that only a template is returned, which is useful. However, it does not clarify whether all input schema parameters are ignored, whether the template varies, or what side effects to expect.

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

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

The description is very concise: two short sentences with the main capability front-loaded and the behavioral caveat appended. No unnecessary words. It is slightly cryptic, especially 'Prompt discarded,' but for a simple tool it remains appropriately sized.

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

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

The description leaves important questions open: what the three-step template looks like, whether any of the seven parameters matter, and whether the tool can be called without arguments. Given the large sibling tool set and no output schema, this is too little context for confident correct invocation.

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

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

The input schema has rich per-parameter descriptions covering all seven parameters, so baseline is 3. The tool description itself adds nothing about parameters. The schema's repeated 'discarded' notes hint that inputs may be irrelevant, but the description does not confirm how parameters interact with the tool.

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

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

The description clearly states the tool's result: it returns a three-step thinking template. 'Prompt discarded' adds a clarifying behavior that distinguishes it from prompt-processing tools. It is slightly thin on what the template actually contains, but the main 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 explicit guidance on when to use this tool versus any of the many sibling tools. The phrase 'Prompt discarded' implies it is for generic template retrieval, but it does not say when it should be preferred or what alternatives exist.

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

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

With no annotations, the description must carry the behavioral burden. It implies a read-only lookup by saying 'Current time', which is useful. However, it does not disclose return format, invalid-timezone behavior, or that the many unrelated schema parameters are discarded beyond what the schema already states.

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

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

The description is a single concise sentence with no filler. It front-loads the core purpose and avoids redundant restating of the tool name.

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

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

Despite the simple purpose, the tool has nine optional parameters, no annotations, and no output schema. The description does not specify which parameter to pass, what the response looks like, or how errors such as invalid timezone names are handled. The schema partially compensates, but the description alone is insufficient for confident invocation.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds little beyond the 'IANA timezone' concept, which is already present in the zone parameter description. It also does not clarify which of the nine optional parameters is the one intended for use.

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 and resource: it provides the current time for a named IANA timezone. This distinguishes it from siblings like utc-time (current UTC time) and iana-zones (lists zone names). It is specific, not a tautology.

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 the agent needs the current time in a specific IANA timezone. However, it does not explicitly mention alternatives or conditions, such as using utc-time for UTC or iana-zones to list valid 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 burden but does not state whether parameters are ignored, whether there are side effects, or what output format is returned. Basic behavior is implied but not elaborated.

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 contains no redundant wording. It front-loads the key information effectively, even though it is minimal.

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

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

Despite the presence of nine optional parameters, the description does not explain how they interact with the tool or whether they are ignored. No output format is specified, leaving important context missing.

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 covers 100% of parameters, so baseline is 3. The main description adds no parameter meaning, and while the schema descriptions are present, they describe parameters seemingly unrelated to UTC time without clarifying their role.

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?

Clearly states the tool returns the current UTC timestamp, which distinguishes it from timezone-related siblings. Lacks an explicit verb but the intent 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?

Provides no guidance on when to use this tool instead of related tools like timezone or iana-zones. The usage context is only weakly implied by 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, the description carries the behavioral burden, and it clearly discloses that the body is discarded, meaning the tool performs a non-persistent check. It does not state what happens for invalid JSON or what the return value looks like, so some behavioral detail is still missing.

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

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

Two short sentences with no filler. The primary purpose is stated first, and the key side-effect is stated immediately after.

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

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

The description is adequate for a simple validation tool and the schema covers the parameters, but there is no annotation coverage and no output schema to clarify the return behavior. An agent may still wonder whether the tool returns a boolean, raises an error, or has other observable side effects.

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 eight parameters have descriptions, and the discard behavior is already documented per-parameter. The tool description adds little semantic meaning beyond confirming that the body is discarded, so the schema remains the primary source of parameter understanding.

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

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

The description states a specific action ('Check whether... valid JSON') on a clearly identified resource (the body), which directly matches the tool name. This distinguishes it from sibling checks like file-path-ok or browser-url-ok.

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

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

The description implies a validation-only use case but gives no explicit when-to-use or when-not-to-use guidance. It does not name alternatives or explain how an agent should choose this tool over sibling shape-checking 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 present, so the description carries the full behavioral disclosure burden. It only states the data source and operation; it does not disclose output format, units, error behavior, rate limits, network dependency, or whether the value is cached or live.

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

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

The description is a single, short sentence with no wasted words and front-loads the key concept. It is appropriately concise for a simple lookup, though it is a sentence fragment rather than a full imperative sentence.

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

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

For a tool with 9 optional parameters, no output schema, and no annotations, this description is under-specified. It does not explain the return value format, which parameter is required, why many unrelated parameters exist, or how failures should be handled; the schema compensates somewhat, but the description alone is not 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%, and the schema itself provides detailed per-parameter semantics, including which fields are discarded. The description adds no parameter-specific detail, so the baseline of 3 applies; the description does at least align with the 'city' parameter.

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

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

The description clearly identifies the resource (current temperature) and scope (a city), with a named source (Open-Meteo). It is specific enough to separate from most sibling tools, though it is phrased as a noun phrase rather than an imperative verb and does not explicitly name 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 use when current temperature for a city is needed, but it provides no explicit when-to-use guidance, no prerequisites, and no exclusions or comparisons to sibling tools. For a tool with nine optional parameters, this is insufficient routing information.

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

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

No annotations exist, so the description carries the full disclosure burden. It does add one honest behavioral detail ('Body discarded'), but it conceals the dominant behavior revealed by the schema: nearly every parameter is accepted and discarded after a 'shape check'. The description also conflicts with the url parameter's own meaning ('normalize or cite') versus the stated purpose of returning HTTP status and content type.

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 key constraint (body discarded) is front-loaded. However, the brevity comes at the cost of omitting the tool's actual multi-parameter scope, so it is not clean conciseness but rather 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?

This is a 9-parameter tool with no annotations and no output schema, yet the description covers only the URL-status aspect. An agent has no way to know what happens with city, json, path, zone, query, ref, feed, or host inputs, nor what the return value looks like. For this complexity level, the description is severely 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 description coverage is 100%, so the baseline is 3 even though the description adds no parameter-level meaning. The described behavior maps to only one of nine parameters (url), and the mismatch between the description and the parameter descriptions (normalize/cite vs. HTTP status check) means the description provides no real 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 states a specific verb and resource ('HTTP status and content type for a public URL'), but it is misleading relative to the input schema, which accepts 9 unrelated input types (city, json, path, zone, query, ref, feed, host) and discards most of them. An agent cannot tell that this is effectively a multi-purpose validation dispatcher, and the description does nothing to distinguish web-fetch from nearby siblings like fetch-status, browser-url-ok, or normalize-url.

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

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

There is no guidance about when to use this tool versus its many siblings. No conditions, exclusions, or alternative references are given, so an agent has to guess which of the similar URL/status/validation tools to pick.

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

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

With no annotations, the description must fully disclose behavior, but it only states that the 'Title discarded after the call' – a minor detail. It does not explain what the tool actually does with each input, what constitutes 'exists', or what the output is. The parameter descriptions mention 'discarded after the shape check' and 'no disk access', but these are in the schema, not the description. The description adds very little behavioral context.

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 brief, but brevity is not conciseness when it omits critical information. It consists of two short sentences that under-specify the tool's purpose and behavior. The description does not front-load essential details and leaves the agent guessing about how to invoke it correctly.

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

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

Given the complexity (9 parameters, no output schema, no annotations), the description is severely incomplete. It does not explain what the tool returns, how it handles the various input types, or what conditions make a title 'exist'. The mismatch between the description and schema means an agent cannot correctly infer how to use 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?

Schema coverage is 100%, so the baseline is 3, but the description fails to clarify which parameter corresponds to the 'Wikipedia title' mentioned in the description. The schema parameters are generic and include descriptions like 'Git ref name; discarded after the shape check' and 'Search text; discarded after the length check', which do not align with a title check. The description adds confusion rather than resolving the ambiguity.

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

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

The description states a clear action ('Check whether a Wikipedia title exists') but the input schema contains no parameter for a title, making the purpose misleading. The name 'wiki-title-ok' suggests a Wikipedia title check, yet the schema includes generic fields like 'ref', 'url', 'city', etc., none of which clearly map to a title. This mismatch between description and schema undermines clarity.

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

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

No guidance is provided on when to use this tool versus alternatives like 'browser-url-ok' or 'file-path-ok'. There is no mention of exclusions, prerequisites, or context that would help an agent select this tool over its siblings.

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