ISO country MQ

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

The description does add a concrete behavioral disclosure: 'Task text discarded.' The word 'Returns' also implies a read-only lookup, which is useful. However, with no annotations at all, the description does not state authentication requirements, side effects, rate limits, or whether remote calls are made, 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 description is compact: three short sentences with the purpose front-loaded and no filler. The terms 'Monid' and 'remote MCP hops' are somewhat cryptic, but the text earns its space and is efficient.

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

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

This tool has 9 heterogeneous optional parameters, no output schema, and no annotations, creating a high-complexity context. The description never explains which parameter to pass, what 'Monid' actually is, how the returned artifacts relate to invocation, or what the agent should do with the result. Significant guidance gaps remain.

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

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

Schema description coverage is 100%, so the schema already documents each parameter individually. The tool description itself adds no parameter-level meaning beyond a general 'Task text discarded' note, so the baseline of 3 is appropriate.

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

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

The description states a specific verb ('Find') and a specific resource ('a public pay-per-call tool gateway (Monid)'), and lists the expected returned artifacts: CLI setup, how-it-works, skill file, and remote MCP hops. It does not explicitly contrast itself with sibling tools, but the object is clearly different from the utility-check tools in the sibling list.

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 'when to use' guidance, no exclusions, and no alternative tool is named. 'Task text discarded' hints at a boundary, but the description does not tell the agent when to select this tool over any sibling or how to decide which of the 9 optional parameters applies to a given request.

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

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

With no annotations present, the description carries the transparency burden. It proactively states that no browser is launched, which is a meaningful behavioral disclosure. However, it does not clarify whether any network request is made, what side effects may occur, or what the result represents.

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

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

The description is short and front-loaded, with two sentences containing no filler. It is efficiently worded, though given the large schema and sibling set, a bit more guiding context would be beneficial.

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, the description is too sparse. It does not explain how the parameters should be combined, what 'can be opened' means operationally, or what the tool returns. The sibling list suggests a shape-check family, but the description does not connect to that 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 description coverage is 100%, so the schema already documents each parameter. The description adds no parameter-level meaning beyond the schema, making the baseline score of 3 appropriate. It does not explain how the many optional parameters relate to the stated URL-checking 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 verb and resource: 'check whether a URL can be opened.' It also adds a key differentiator from browser-launching siblings via 'No browser is launched.' However, the large set of unrelated input parameters makes the exact scope slightly ambiguous.

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

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

The description implies a use case—checking URL openability without launching a browser—but it gives no explicit guidance on when to choose this over siblings like playwright-url-ok, fetch-status, or normalize-url. No exclusions 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, the description must carry behavioral disclosure. It only says 'Expression discarded,' which is vague and does not specify side effects, return values, failure modes, or the fate of the many schema parameters. It also implies an arithmetic expression input that is not present in the schema.

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

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

The description is short, but brevity is not serving clarity here. The second sentence, 'Expression discarded,' repeats an idea that already confuses the tool's purpose and does not earn its place. The description is under-specified rather than efficiently concise.

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

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

This tool has 9 heterogeneous parameters, no output schema, and no annotations, so the description carries the full burden of explaining usage. A two-sentence arithmetic statement does not explain which parameter to supply, what the tool returns, or why the schema contains unrelated validation fields. It is completely inadequate for an agent to select and invoke this tool correctly.

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

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

Schema description coverage is 100%, which normally earns a baseline of 3. However, the tool description refers to an arithmetic expression that maps to no parameter, while the actual parameters describe unrelated checks (Git ref, URL, city, RSS feed, host, JSON, file path, timezone, query). The description therefore adds confusion rather than semantic value.

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

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

The description names a specific action ('Evaluate a+b style arithmetic'), but the input schema contains no expression parameter and instead lists 9 unrelated string fields such as ref, url, city, json, and path. It does not distinguish this tool from the many sibling validation and shape-check tools, and the relationship between the description and the actual resource operated on is unclear.

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

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

No guidance is provided about when to use calc-eval versus alternatives like browser-url-ok, validate-json, or domain-shape. The phrase 'Expression discarded' does not help an agent decide whether this tool applies to the current task.

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

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

With no annotations, the description carries the burden of disclosing behavior. It does disclose a meaningful privacy trait ('Page content is not stored') and the limited return set. However, it does not mention whether a network request is made, potential side effects on the target URL, or how extraneous input fields are handled, though the schema partially covers the latter.

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 that front-load the return value and add a privacy note. Every word contributes meaning, and the structure makes the tool's primary behavior 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?

For a tool with nine parameters, no annotations, and no output schema, the description is fairly minimal. It does cover the core return values and the non-storage guarantee, and the schema fills in parameter details, but it does not explain which inputs are meaningful, how the unrelated fields relate to the call, or what the response structure looks like.

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

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

The input schema describes all 9 parameters in detail, so the baseline is 3. The description adds little beyond the fact that a URL is the core input, which is already present in the url parameter's schema description. No additional parameter semantics or relationships are explained.

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

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

The description clearly states a specific action and result: 'Return host, scheme, and HTTP status for a URL.' The added phrase 'Page content is not stored' helps differentiate this from content-fetching tools like web-fetch, though it does not explicitly name any sibling alternative.

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 siblings such as fetch-status, normalize-url, or browser-url-ok. No prerequisites, exclusions, or alternative selection conditions are provided, leaving the agent to infer usage purely from the terse 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 transparency burden. It does disclose one meaningful behavioral trait: 'No identifiers are retained.' It also identifies the main action as classification. However, it remains silent on whether the operation is local, whether it has side effects, what data is processed, and what the output looks like, 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 description is compact and front-loaded: the primary action comes first, followed by the privacy guarantee. There is no fluff, and both sentences earn their place. It is under-specified, but that is a completeness issue rather than a conciseness or structure problem.

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

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

For a tool with nine heterogeneous optional parameters, no output schema, and no annotations, this description is severely inadequate. It does not state what 'classification' is, what output the agent should expect, which parameters are relevant, or how to construct a valid call. A 9-parameter tool needs far more context than this.

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 description coverage is 100%, and each parameter already has a semantic description in the schema. The tool description adds no parameter meaning, but because the schema fully documents the parameters, 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 verb and resource—'Show how this request is classified'—but never explains what 'classified' means, what classification categories exist, or how the result relates to the tool name 'compatibility'. It is not a pure tautology, but it is too vague to let an agent know what the tool actually produces.

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

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

There is no guidance about when to use this tool, what inputs to supply, how to choose among the nine optional parameters, or when a sibling like validate-json, normalize-url, or timezone would be more appropriate. The description provides no usage context at all.

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?

In the absence of annotations, the description does provide some behavioral context: it states that WHOIS and ownership data are not included and the operation is a pure split. It leaves gaps around whether any network access occurs, how the non-host parameters are treated, and what exact shape the labels result takes, so it is adequate but not rich.

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

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

The description is one tight sentence with no filler. It front-loads the action and the key limitation, making it very easy for an agent to parse the core purpose 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?

With nine optional parameters, no required parameters, no output schema, and no annotations, the single sentence is not enough context. It does not tell the agent which parameter to populate, why the other parameters appear in the schema, or what format the returned labels take.

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 every parameter already has its own description. The tool description adds no parameter-level meaning and does not explain why eight of the nine accepted properties are unrelated to splitting a hostname.

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

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

The description clearly names the operation and resource: 'Split a hostname into labels', and it adds a meaningful non-goal, 'without WHOIS or ownership data', that distinguishes it from lookup and availability tools. It is not a 5 because the nine-parameter schema includes many unrelated fields such as city, json, and query, which the description never reconciles with the hostname-only purpose.

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

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

No when-to-use guidance is given relative to sibling tools such as normalize-url, browser-url-ok, github-repo-shape, or wiki-title-ok. The 'without WHOIS or ownership data' phrase implies a lightweight use case but does not state conditions, alternatives, or exclusions.

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

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

With no annotations available, the description carries the full burden for behavioral disclosure. It does reveal the HTTP method (HEAD), the public scope, and that only status is returned, but it does not clarify behavior for the other eight parameters, what the status output looks like, or whether the operation is purely a shape check versus a network request.

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. However, for a tool with nine optional parameters and no required fields, the brevity crosses from concise into under-specified; there is no structure that helps an agent understand parameter selection.

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 and no output schema, the tool description is far from complete: it does not define the return format, explain how non-URL parameters are handled, or indicate whether the parameters are mutually exclusive or combinable. An agent would only be able to confidently use fetch-status in the simple URL case.

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

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

Schema description coverage is 100%, so each of the nine parameters already has a per-parameter description and the baseline of 3 applies. The tool description itself adds no parameter-level meaning, and the schema descriptions are somewhat disjoint—'normalize or cite,' 'weather hint,' 'discarded after the length check'—but that incoherence is not compensated by the tool description.

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

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

The description names a concrete action, 'HEAD a public URL and return status only,' but the input schema exposes nine disjoint parameter kinds including city, json, path, zone, and query that have nothing to do with HEADing a URL. The stated purpose is therefore incomplete to the point of being misleading, and an agent cannot determine the tool's actual scope from the description alone.

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

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

No guidance is given about when to use fetch-status versus siblings such as web-fetch, browser-url-ok, normalize-url, or status-catalog. There is no when-not-to-use information, no prerequisite context, and no explanation of which of the nine optional parameters should be supplied for which task.

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

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

With no annotations, the description carries the full burden. It discloses only that a path is discarded, but says nothing about whether the operation is read-only, what it returns, whether the URL is validated, or how failures behave.

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 five-word description is brief with no wasted words, but it is under-specified rather than usefully concise. It omits essential context and does not earn its minimal 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?

There is no output schema and no annotations, so the description should explain what the tool returns and which inputs matter. It does neither; the nine optional parameters and ambiguous 'Path discarded' leave the agent unable to reliably construct a correct 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?

Although the input schema covers each parameter at 100%, the description does not map 'Figma file URL' to the `url` parameter, and the mention of 'Path discarded' appears to clash with the `path` parameter described as 'File path to check'. The agent cannot tell which of the nine optional parameters are meaningful to this tool.

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

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

The description names a specific verb and resource ('Parse a Figma file URL'), which clearly separates it from sibling tools like github-repo-shape and jira-key-shape. However, 'Path discarded' is ambiguous and it does not state what the parsed result is, so it stops short of a 5.

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

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

No guidance is given about when to use this tool versus alternatives such as normalize-url or browser-url-ok. The only implied context is 'if you have a Figma file URL', with no when-not conditions or exclusions.

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

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

There are no annotations, so the description must carry behavioral disclosure; 'No disk access' is a meaningful guarantee but it is the only one. The description leaves unclear what 'looks safe' means (syntax? traversal? absolute vs relative?), what the return value is, and whether invalid input is an error or a false result. Too much behavior is unstated for a validation tool with no annotations.

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

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

The description is two short sentences with no filler and the key fact ('No disk access') is front-loaded. It is appropriately small for a simple validator, though the extreme brevity leaves semantic gaps that are penalized elsewhere.

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 a nine-property input schema, a two-sentence description is not enough to let an agent invoke the tool correctly. It doesn't specify the return value, the definition of a safe path, or how to deal with the irrelevant schema fields. The description is inadequate for the complexity of the tool's structured definition.

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 schema exposes nine unrelated parameters (url, city, feed, host, json, zone, query, ref) alongside path, and the description never says path is the only meaningful input or that the others are ignored. This is actively confusing for an agent deciding how to invoke the tool. The description adds no clarity about parameter selection.

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

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

The description names a concrete verb and resource: 'Check whether a path looks safe.' It also adds a useful scoping constraint, 'No disk access,' and is clearly distinct from sibling URL/title validators. It stops short of a 5 because 'safe' is left undefined and no return shape is mentioned, so the exact purpose is still slightly ambiguous.

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

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

The statement implies this is the tool to use for a quick, filesystem-free path validation, and 'No disk access' is a relevant selection clue. However, it never names when to prefer it over sibling checks such as browser-url-ok or wiki-title-ok, and it doesn't state conditions or exclusions. Usage context is present but only by implication.

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 it only reveals that Open-Meteo is the backend. It does not mention output format, failure behavior, rate limits, external network dependency, or whether the operation is read-only.

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 fluff, so it scores well on economy. However, for a tool with nine optional parameters and no annotations, it is more under-specified than appropriately concise.

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

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

With nine optional parameters, no output schema, and no annotations, a one-sentence description is completely inadequate. The agent cannot determine how to specify the place, what coordinate format to expect, or what happens when the place is unknown.

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 description coverage is 100%, the description does not map 'a place' to any of the nine optional parameters, and several schema descriptions are confusingly off-topic (e.g., city is 'discarded after the call' and query is 'discarded after the length check'). The description adds no disambiguating meaning, so an agent cannot tell which parameter actually supplies the place.

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

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

The description states that the tool provides latitude and longitude for a place via Open-Meteo, which is a clear enough core function and distinguishes it from siblings like weather-hint or timezone. It lacks an explicit verb like 'returns' or 'resolves,' and 'a place' is vague, but the intent is 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?

There is no guidance about when to use geo-hint versus any of the 29 sibling tools, nor any mention of alternatives or exclusions. The only implied context is that the user needs coordinates, which is not enough to make a confident tool 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?

With no annotations, the description carries the full behavioral burden, but it only states the parse action. It does not disclose whether the tool validates the URL, what invalid inputs do, whether extra schema fields are ignored, or what exactly is returned.

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

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

One short sentence with no filler; the key verb and resource are front-loaded. It earns its place despite being 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?

There is no output schema or annotations, and the tool takes nine parameters while the description explains only one. The definition lacks enough context about output shape, error behavior, and why the other parameters exist, so an agent is under-specified for reliable invocation.

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

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

Schema description coverage is 100%, so the baseline is 3; the description adds no new parameter details beyond identifying that a GitHub URL is the source. The large set of unrelated optional parameters is not reconciled with the stated purpose.

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

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

The description 'Parse owner and repo from a GitHub URL' uses a specific verb and resource, and the GitHub/owner/repo framing clearly separates it from shape tools like figma-url-shape or jira-key-shape. An agent can immediately understand the input and output concept.

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

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

The description implies the use case (extract owner/repo from a GitHub URL) but does not explicitly say when to prefer it over sibling tools such as normalize-url or browser-url-ok. No exclusions or alternative conditions are provided, so the guidance is only inferred.

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 does disclose one meaningful behavior: titles are discarded, so the result is just a count. It omits details like live network access, failure behavior, and whether inputs affect the result, but the disclosed behavior is enough for a basic read-only counter.

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

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

Two short, front-loaded sentences with no filler. The main action appears first, and the clarifying 'Titles discarded' is kept separate.

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 count tool, the description is nearly complete: no required params and a clear purpose, plus a hint that titles are omitted. It still lacks an explicit statement of return type and does not address whether the 9 optional params are ignored, which leaves some ambiguity.

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 explains all 9 parameters. The tool description adds no parameter-specific meaning, which matches the baseline expectation; it also fails to clarify whether any of the many optional params are actually relevant to the count.

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

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

The description names a specific action ('Count') and a specific resource ('current Hacker News front-page stories'), so an agent can tell exactly what the tool does. 'Titles discarded' further clarifies that it is not a story-title fetcher, distinguishing it from general fetch tools.

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

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

The use case is implied by the purpose: call it when you need the number of current HN front-page stories. However, it never explicitly says when to prefer it over siblings, whether parameters are required, 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 available, the description carries the full burden of behavioral disclosure, but it only labels the content as 'common IANA timezone names'. It does not describe return behavior, whether parameters are ignored or used, side effects, or any processing characteristics, and the parameter descriptions in the schema suggest discard behavior that the tool description contradicts.

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 seven words and contains no filler, which is concise. But it is a fragment rather than an instructive sentence, and the vague adjective 'common' and prepositional phrase 'for clock calls' do not carry enough operational meaning to be considered well structured.

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

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

The tool has 9 optional parameters, no output schema, and no annotations, yet the description offers no explanation of what the tool returns, how parameters affect output, or what the parameter names mean in this context. This is far from a complete definition 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?

Schema description coverage is 100%, so the baseline is 3. However, the tool description adds no relation between the parameters and IANA timezone names; several schema descriptions indicate values are 'discarded', which is confusing for a timezone-list tool. The description does not compensate for that mismatch.

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

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

The description identifies the subject (IANA timezone names) and intended domain (clock calls), but it is a noun phrase without a verb, so it does not state what the tool actually does (e.g., returns, lists, resolves). It also does not distinguish it from sibling tools like timezone or utc-time beyond the 'common names' 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?

No guidance is given about when to use iana-zones versus the many sibling tools such as timezone, utc-time, or geo-hint. The only context is 'for clock calls', which implies a narrow use case but never states when not to use it or which alternative to choose.

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 accurately discloses a read-only network fetch of a public resource and limits output, but it omits failure behavior, redirect handling, and any mention that only a specific parameter is used.

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; 'only' sharpens the output contract. Every word earns its place.

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

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

For a tool with no annotations and no output schema, nine optional parameters, and an external fetch, the one-sentence description is incomplete. It does not state which parameter to use, what 'group counts' looks like, or how failures are reported.

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. The description itself adds no parameter mapping, and the generic schema descriptions leave it ambiguous which parameter is the robots.txt target, but that is not penalized beyond baseline per the rubric.

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 ('Fetch'), a concrete resource ('a public robots.txt'), and the exact output scope ('group counts only'). This distinguishes it from general-purpose siblings like web-fetch and fetch-status.

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

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

The use case is implied: when an agent needs group counts from a public robots.txt. However, it gives no explicit when-not-to-use guidance and names no alternatives among the many URL-fetching siblings.

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

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

No annotations are provided, so the description carries the full burden. It does disclose one behavioral trait—'Key discarded'—indicating the input is not retained. But it says nothing about side effects, return values, error behavior, or why the schema contains many unrelated 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 exceptionally short—two sentences with no filler. 'Key discarded' is a meaningful privacy note. However, the brevity borders on under-specification because critical operational details are absent.

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

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

For a tool with nine optional parameters, no output schema, and no annotations, this description is inadequate. It does not explain what the tool returns, which parameter to populate, what 'shape' means precisely, or how this differs from other shape tools beyond the name.

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

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

Schema description coverage is 100%, so a baseline of 3 applies. The description adds no parameter-specific meaning, and more importantly, it fails to link the Jira key concept to any of the nine parameters. The parameter descriptions are generic about the data type, not about the shape check, leaving selection ambiguous.

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: 'Check a Jira issue key shape.' This clearly distinguishes it from sibling shape-checking tools like domain-shape or figma-url-shape. However, it does not identify which of the nine schema parameters should carry the Jira key, leaving the operational target ambiguous.

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

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

Usage is only implied by the tool's name and first sentence. There is no guidance on when to prefer this tool over other shape-checking siblings, nor any mention of what types of inputs are appropriate. With many similar sibling tools, the lack of explicit routing is a significant gap.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose that the body is discarded, which is useful for an agent deciding whether this tool provides enough information. However, it does not describe the return format, whether the URL is fetched over the network, or 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 only 11 words across two sentences and front-loads the action. It is free of filler, but its brevity sacrifices a useful pointer to the relevant parameter.

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

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

For a tool with 9 optional parameters, no annotations, and no output schema, this description is under-specified. An agent cannot tell whether to use url, city, feed, json, or another field, nor what the returned HTTP status looks like. The mismatch between the narrow description and the broad schema leaves a significant gap.

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

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

Schema description coverage is 100%, so the input schema already documents all 9 parameters. The description adds no param-specific meaning and never indicates which parameter applies to 'lib-docs-hint'; it only mentions 'URL' generically, leaving the other 8 parameters unexplained in context.

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 outcome—HTTP status for a URL—and notes that the body is discarded, so it is not a pure tautology. However, 'public library docs URL' is vague and does not distinguish this tool from siblings like fetch-status or browser-url-ok. The schema also lists 9 unrelated parameters, so the description does not clarify the tool's actual scope.

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

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

There is no explicit guidance about when to use this tool versus siblings such as fetch-status, normalize-url, or web-fetch. 'Body discarded' is a hint that the body is not returned, but it is not a clear when-to-use or when-not-to-use 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?

With no annotations, the description carries the behavioral burden. It usefully discloses that values are discarded, which is a meaningful behavioral trait, but it says nothing about invalid JSON, empty objects, recursion, or whether the operation has 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 short and front-loaded, with no wasted words. It earns a high conciseness score, though the brevity leaves important operational context unstated.

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 nine-parameter tool with no annotations and no output schema, this is incomplete: it does not define the output shape, the target parameter, or behavior on invalid input. It is minimally usable, but the agent must 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?

Although schema coverage is 100%, the description adds no mapping to the nine optional parameters, and even the schema's 'json' parameter is described as validation rather than as the object whose keys are counted. An agent cannot reliably determine which parameters 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 names a concrete action (count keys) and resource (JSON object), and 'values discarded' helps distinguish it from validation or extraction tools. It is slightly weakened by not tying the JSON object to any of the input schema's parameters and not clarifying nested vs top-level keys.

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 choose this tool over siblings such as validate-json or domain-shape, nor any when-not-to-use conditions. 'Values discarded' implies it is for count-only needs, but the tool never makes that explicit.

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

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

With no annotations, the description carries the transparency burden. It does disclose a meaningful behavior—query and fragment are dropped—but it does not mention error handling, URL validation behavior, or the exact returned structure beyond naming three components.

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 states the core behavior and the key exclusion in under fifteen words.

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

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

The tool is simple and the description names the returned components, but there is no output schema and no annotation coverage, so the exact return format is unspecified. The presence of nine optional parameters also makes it less obvious which parameter is actually relevant, though the schema descriptions mitigate this.

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

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

Schema coverage is 100%, so the baseline is 3; the description adds value by explaining that a URL's query and fragment are intentionally discarded, which clarifies the effect of the `url` parameter. It does not explain the many unrelated optional parameters, 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?

The description states a precise verb and resource: return origin, host, and path for a URL. It also explicitly says query and fragment are dropped, which makes the tool's scope unusually clear and distinguishes it from URL-fetching or URL-checking siblings.

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

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

The description implies the tool is for extracting normalized URL components when query and fragment are not needed, but it does not explicitly say when to prefer this tool over alternatives like web-fetch or browser-url-ok. No when-not-to-use or alternative guidance is provided.

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

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

With no annotations, the description must disclose behavior, but it only says no browser is launched. It does not state that this performs a network request, whether it is read-only, what 'opened' means, or what the tool returns. Key behavioral expectations are left to inference.

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

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

Two short, front-loaded sentences make the main point immediately. The prose is efficient, though it omits necessary context that would reduce ambiguity.

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 parameters, no annotations, and no output schema, but the description is only one sentence about URLs. It does not explain the role of city, feed, json, host, or query params, nor what the tool returns. An agent cannot confidently select and invoke the correct option from this description alone.

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

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

Schema description coverage is 100%, so the parameters are individually documented. The description adds no parameter guidance and does not explain which of the nine parameters is primary or how they interact with the URL check.

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

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

The description states a specific verb ('Check') and resource ('whether a URL can be opened'), and the note 'No browser is launched' differentiates it from browser-url-ok. It is slightly vague about what 'opened' means, but the core action is clear.

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

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

The 'No browser is launched' clause implies this is the lightweight alternative to a browser-based check, but the description does not explicitly name alternatives or state when to use this tool over fetch-status or normalize-url. No 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 statement 'Query discarded' discloses a data-handling behavior (no persistence) but this is also already present in the query parameter schema. With no annotations, the description still leaves return format, failure behavior, and treatment of the other fields unspecified.

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

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

The description is extremely compact and front-loads the main purpose. It loses one point because 'Query discarded' repeats information already in the schema rather than adding new value.

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 and no output schema, the description leaves some ambiguity, but the schema plus the word 'count' give a minimally viable contract. It does not explicitly state that only the query parameter matters or what the exact return type is.

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 description does not need to compensate for missing parameter docs. It adds only the high-level phrase 'search query' while the query parameter description already says 'Search text; discarded after the length check.'

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

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

The description specifies a concrete action ('Count characters') and a concrete resource ('a search query'), which clearly sets it apart from sibling count/length tools like memory-key-count and hn-front-count. It is not a tautology because it spells out the unit of measurement.

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 note about which of the nine optional parameters is the relevant one. The agent must infer usage from the tool name and the input schema.

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 of behavioral disclosure. It reveals no behavior beyond a noun phrase: no return format, no side effects, no read-only indication, and no mention that the parameters appear to be 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 short, but it is under-specified rather than helpfully concise: it omits the action, usage context, and output expectation. The word 'Short' adds little beyond the name and does not earn its place.

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

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

With seven parameters and no output schema, a one-line noun phrase is not adequate. The description does not explain why the parameters exist, whether any are required, or what the returned catalog looks like.

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

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

The input schema documents all seven parameters with descriptions, so schema coverage is high and the baseline is 3. The description itself adds no guidance on how or whether to supply any parameter, and the parameters are oddly unrelated to a status-code catalog, each repeatedly marked 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?

The description identifies a resource—common HTTP status codes—and suggests the tool is a catalog, but it lacks an explicit verb such as 'returns' or 'lists', so the action is implied rather than stated. It also does not distinguish the tool from the sibling fetch-status, which could be confused with status-code retrieval.

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 when-to-use guidance, no conditions, and no mention of alternative tools. Usage is only vaguely implied by the word 'catalog' and 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose the most important trait — that inputs are discarded and a fixed template is returned — which prevents an agent from expecting its question to be answered. However, it does not describe what the template contains, whether parameters affect output, or any side effects, so disclosure is thin but not misleading.

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

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

Two sentences with zero filler: the first states the function, the second the critical caveat. Every word earns its place and the key behavior is front-loaded.

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

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

For a tool with 9 parameters, no output schema, and no annotations, this description is too thin. An agent cannot tell what the three-step template looks like, whether it should pass any parameters (all are optional and discarded), or what the response will contain. The schema covers parameter meanings, but the overall contract of the tool is unexplained.

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 schema already documents all nine parameters, including their discarded-after-check behavior. The tool description itself adds no parameter-level information, which is acceptable given the high schema 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?

"Return a three-step thinking template" states a specific verb and resource, and the discard caveat makes the behavior unambiguous. The sibling set is all validation/normalization/check tools (validate-json, file-path-ok, domain-shape), so this template-returning tool is clearly differentiated. It loses a point because the three-step template is never elaborated — what steps, for what 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 indication of when to call this tool versus any of the 28 siblings. It does not name alternatives, state prerequisites, or give conditions. The only hint, "Prompt discarded," is a behavioral caveat, not usage guidance.

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

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

With no annotations, the description carries the full behavioral burden, but it only says 'Current time...' and provides no detail on return format, invalid-zone handling, or whether date/offset is included. Worse, the input schema is filled with unrelated 'discarded after' parameters, so the actual behavior is not transparent.

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

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

The description is a single, front-loaded sentence with no filler. It is concise, but its brevity contributes to the omission of critical invocation details.

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, this description is grossly incomplete and actually inconsistent with the schema. An agent cannot determine which parameter to populate to get the time in an IANA timezone, making the tool effectively uncallable as documented.

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 parameters are overwhelmingly unrelated to the described tool: ref, url, city, feed, host, json, path, and query are each described for other purposes, and none accepts a timezone ID. The description promises a 'named IANA timezone' input, but no such parameter exists and all parameters are optional.

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 exactly what the tool returns: the current time in a named IANA timezone. This is specific and distinguishes it from siblings like utc-time and iana-zones, though it does not mention them explicitly.

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

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

The description implies the tool should be used when an agent needs the current time in a specific IANA timezone rather than UTC or a list of zones. However, it never explicitly states when to use it versus alternatives or gives exclusion 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?

There are no annotations, so the description must carry the behavioral burden. It accurately implies a side-effect-free, read-only operation, but it does not explicitly state that all seven input parameters are optional/ignored or that the result is independent of them; the schema property descriptions carry that information instead.

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 three words and front-loaded; every word contributes meaning. 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?

Given seven unrelated optional parameters, several sibling tools, and no output schema, the description is too thin: it does not state the timestamp format (e.g., ISO string vs epoch), that all parameters are ignored, or how this differs from timezone/iana-zones. The schema covers parameters but not the tool's role or return 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?

The description says nothing about parameters, but the input schema already provides detailed descriptions for all seven properties (roughly 100% coverage), including explicit 'discarded' and 'no disk access' notes. Per the baseline for high schema coverage, the description does not need to restate 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 identifies the core output — 'Current UTC timestamp' — with a clear resource and scope (UTC time). It is not a tautology of the tool name, but lacks an explicit verb and does not differentiate from sibling time-related tools like timezone or iana-zones.

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

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

The description gives no guidance about when to choose this tool over siblings such as timezone, web-fetch, or validate-json, and no exclusions or alternatives. The word 'Current' implies a clock read, but the context for routing is missing.

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 does disclose a non-obvious side effect—the body is discarded—which is useful. However, it does not explain what happens for valid versus invalid JSON, whether an error is raised, or what the tool returns, so transparency is incomplete.

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

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

Two short, front-loaded sentences deliver the core action and the key side effect with no filler. Every sentence earns its place.

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

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

The tool has no annotations and no output schema, yet the description omits the return/error contract and does not explain how the seven parameters relate or that 'json' is the meaningful one. The discarded-body note helps, but an agent still lacks enough context to confidently handle invalid input or select the correct parameter.

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, with every parameter having a description, so the baseline is 3. The description itself adds no parameter-level meaning and introduces ambiguity with the word 'body' when the schema exposes a 'json' parameter plus several unrelated-looking parameters. The schema carries the parameter semantics, not the description.

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') and a clear resource ('whether a body is valid JSON'). The tool name reinforces the purpose, and this is enough to distinguish it from sibling validators such as domain-shape, file-path-ok, or browser-url-ok, which target different input types.

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 the many sibling validation/shape tools, and no explicit exclusions. The only selection signal is the tool name and the word 'JSON', so the agent is left to infer when this is the right choice.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the Open-Meteo source but does not disclose that 8 of the 9 schema parameters appear unrelated and are described as discarded after shape checks. It also does not mention output format, error behavior, or whether the city parameter is genuinely required despite being optional in the schema.

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

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

The description is short, front-loaded, and free of filler. However, given the schema's nine optional parameters and the mismatch between the tool's weather purpose and most parameters, the brevity feels more like under-specification than optimal conciseness.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, the description is incomplete. It fails to explain which parameters are relevant to the weather call, what happens to the other parameters, or what response format to expect. An agent would likely be confused by the unrelated schema fields.

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

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

Schema description coverage is 100%, so the baseline is 3. The schema already documents each parameter, including the city field and the discarded/check behavior of the others. The description only reinforces that city is the relevant parameter for weather and does not add substantive 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 clearly identifies the tool's intent: retrieving a city's current temperature via Open-Meteo. It does not explicitly use a verb like 'gets' or 'returns,' but the meaning is unambiguous. It does not compare itself with siblings, but none of the listed siblings overlap directly with weather data.

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

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

The description gives no guidance on when to use this tool instead of alternatives such as geo-hint or other hint tools. It also does not clarify how to treat the many unrelated optional schema parameters. 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 no annotations, the description carries the burden of behavioral disclosure. It usefully discloses that the body is discarded and that only public URLs are relevant, but it does not mention redirects, error handling, response shape, or other network behavior an agent might need.

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: two short sentences, no filler, and the key side effect ('Body discarded.') is stated explicitly. 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 core purpose and the main discarded-body behavior, and the schema covers all parameters. Still, with nine parameters, no output schema, and many sibling tools, the absence of usage guidance and clarification of which parameter matters leaves notable gaps for an agent selecting and invoking the tool.

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

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

Schema coverage is 100%, so the baseline is 3; every parameter has a description. However, the tool description does not clarify which of the nine parameters is the actual URL to fetch, and the url parameter's schema text says 'normalize or cite' rather than fetch, adding some 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 clearly states that the tool returns HTTP status and content type for a public URL and that the body is discarded. It is specific about the outcome, but it lacks an explicit action verb and does not directly differentiate itself from sibling tools like fetch-status or browser-url-ok.

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

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

The description provides no guidance about when to use this tool versus siblings such as fetch-status, browser-url-ok, or normalize-url. There are no usage conditions, exclusions, or alternative tool mentions, leaving the agent to infer when this tool is the right choice.

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

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

No annotations are provided, so the description must carry the transparency burden. It adds a data-handling note ('Title discarded after the call'), but does not explain side effects, return value, network access, or failure behavior; and the note is confusing because the schema has no title parameter.

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 brief and front-loaded, but the second sentence is nearly useless without a title parameter and the definition lacks any structure or usage section. It is terse rather than fully 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 seven parameters and no output schema or annotations, the description is far too thin. It omits the core parameter mapping, return type, and selection context, so an agent cannot safely or correctly use the tool.

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

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

The schema exposes seven unrelated string fields (ref, url, city, feed, host, json, path) with their own descriptions, but none corresponds to a Wikipedia title and the description does not say which parameter to use. Correct invocation is effectively impossible from this definition.

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

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

The description clearly names a specific action and resource: checking whether a Wikipedia title exists. It is distinct from sibling shape/URL/weather tools, though it does not explicitly differentiate itself or state what result is returned.

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 web-fetch, normalize-url, or other shape checks. An agent is left to infer the intended context from the name and description.

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