ISO country NZ

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

There are no annotations, so the description carries the disclosure burden. It does disclose a notable behavior ('Task text discarded') and the 'Find/Returns' framing suggests a read-only lookup. However, it is silent on side effects, external calls, or cost implications of a 'pay-per-call' gateway.

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 deliver the purpose, the deliverables, and a behavioral caution with no filler. The core action is front-loaded in the first 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?

The description does not tell an agent how to form a call: six heterogeneous parameters are present, but there is no indication of which to supply, whether any are required, or how they map to finding Monid. With no output schema and no required-field information, important invocation context is 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?

The input schema already describes all six parameters with 100% coverage, including their 'discarded after' behavior. The description adds no parameter-level meaning beyond the standalone statement that task text is discarded, which is not tied to any specific 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 names a specific operation and resource: 'Find a public pay-per-call tool gateway (Monid)' and lists concrete deliverables (CLI setup, how-it-works, skill file, remote MCP hops). It is not a tautology and does not resemble any of the sibling tools, though 'Monid' is unexplained and the connection to the six input parameters 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?

The intended use is implied: invoke this tool when you need Monid's CLI setup, how-it-works, skill file, or remote MCP hops. However, there is no explicit when-to-use or when-not-to-use guidance, and no alternatives are mentioned.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose that no browser is launched, which is useful, but it fails to explain how 'can be opened' is determined, whether a network request is made, whether inputs are discarded, or what side effects might occur. The schema's repeated 'discarded after the check' hints at important behavior that the description omits.

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 main function appears first, followed by a key behavioral qualification. Both sentences earn their place, and there is no wordy filler. It loses one point because it is so minimal that it under-specifies the tool's broader parameter surface.

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

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

Given 9 optional parameters, no annotations, and no output schema, this one-sentence description is not enough for an agent to understand how to invoke the tool correctly. It does not state what the tool returns, how multiple parameters interact, or which parameter is relevant for the stated URL-checking purpose. The rich schema descriptions mitigate but do not compensate for the missing overall behavioral 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 baseline is 3 even without parameter details in the tool description. The description adds no parameter-level meaning; it only mentions 'URL' while the schema documents many unrelated optional parameters. Since the schema already explains each parameter, a 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 gives a clear verb and resource: 'Check whether a URL can be opened.' However, the input schema contains 9 parameters that are not URL-only (git ref, city, RSS feed, JSON, timezone, query), so the stated purpose does not match the actual breadth of the tool. It also does not differentiate this tool from closely related siblings like normalize-url, fetch-status, or playwright-url-ok beyond saying no browser is launched.

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 choose this tool over alternatives. The only contextual hint, 'No browser is launched,' implies a use case where browser side effects should be avoided, but the description never states exclusions, alternatives, or conditions such as 'use fetch-status for live HTTP checks' or 'use playwright-url-ok when browser rendering is needed.'

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 only states 'Expression discarded', but it does not clarify whether the evaluation result is returned, whether all inputs are discarded, or what the tool actually does with the nine provided parameters. This is insufficient for a tool with no output schema and no annotation safety 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 very short and contains no filler, and the key action is front-loaded. However, it is under-sized for a tool with nine parameters and no output schema; it omits essential information while remaining 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?

Given the tool's 9-parameter schema, absent output schema, and complete lack of annotations, this description is grossly incomplete. It does not explain which parameter carries the arithmetic expression, what the tool returns, what 'discarded' means for output, or how this tool relates to the surrounding sibling shape-check tools.

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

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

Although schema coverage is 100%, the description introduces an 'expression' concept that is absent from the schema, so it actively confuses parameter mapping. An agent reading the description would look for an arithmetic expression field, but all parameters are unrelated string fields like host, json, and zone.

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

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

The description says 'Evaluate a+b style arithmetic', which names a specific verb and object, but the input schema has no expression parameter at all—only ref, url, city, feed, host, json, path, query, and zone. This means the stated purpose cannot actually be realized from the schema, making the description misleading rather than actionable.

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

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

The description gives no guidance about when to use this tool versus alternatives such as validate-json, timezone, normalize-url, or the other sibling shape-check tools. There is also no mention of exclusions or prerequisites, so an agent cannot determine appropriate call conditions.

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

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

With no annotations, the description carries the transparency burden. It adds a meaningful privacy behavior ('Page content is not stored') and states what is returned, but it does not mention side effects, errors, or how the many discardable parameters behave beyond what the schema already says.

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 main result is front-loaded and the privacy note is a single useful addition.

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

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

Despite a many-parameter schema and no output schema, the description explains only the URL-related behavior and leaves the purpose of the other parameters and the expected call pattern unexplained. An agent cannot confidently determine the correct inputs from the description alone.

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

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

The schema already covers the parameters at 100%, including discard behavior for each field. The description adds no parameter-level detail beyond naming URL, so the baseline 3 applies.

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

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

The description clearly states a concrete verb and resource: it returns host, scheme, and HTTP status for a URL. However, it does not differentiate this from sibling tools like fetch-status 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?

The description implies when to use the tool (when URL host/scheme/HTTP status is needed), but it provides no explicit comparison, exclusions, or alternative tool names. The context is minimal and left to inference.

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

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

With no annotations, the description must carry the burden of behavioral disclosure. It does provide a useful data-handling guarantee in 'No identifiers are retained,' which complements the per-parameter discard notes. However, it does not disclose whether the operation has side effects, what output is produced, or any other operational behavior.

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

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

The description is two short sentences with no filler, states the main idea first, and adds a meaningful privacy note in the second sentence. It is appropriately concise, though its brevity contributes to missing operational context.

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

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

For a tool with nine optional parameters and no output schema, this description is incomplete: it does not explain how classification works, what the returned classification looks like, or which parameter should be supplied in which scenario. The privacy disclosure is helpful but not sufficient for an agent to invoke the tool 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 each of the nine parameters is already individually documented. The description does not add parameter-specific meaning beyond the general privacy statement, but the schema carries the semantic load.

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 gives a verb and a general subject, but 'how this request is classified' does not specify what classification scheme is used, what 'compatibility' means, or how this tool differs from siblings. It is vague rather than a pure tautology or completely missing.

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 domain-shape or normalize-url, and no conditions for choosing among the nine optional parameters. The privacy note does not help an agent decide when to call 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 provided, the description carries the full burden. It does disclose a meaningful behavioral trait: the tool does not fetch WHOIS or ownership data. However, it does not mention output format, failure behavior, network access, or whether inputs are discarded, 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 a single, direct sentence with no filler. It front-loads the action and scoping constraint efficiently, making it easy to parse.

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

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

The tool has 9 optional parameters, no annotations, and no output schema, yet the description only covers hostname splitting. It does not clarify which parameter to use, what the output looks like, or how it relates to the many sibling shape tools. The mismatch between the narrow description and the broad schema leaves 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?

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning beyond the schema, and it fails to specify that the 'host' parameter is the intended input while the other parameters appear unrelated or are marked discarded. The schema itself provides clear descriptions, so the agent can still infer the likely 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 states a specific verb ('split') and resource ('hostname into labels'), and adds a clear exclusion ('without WHOIS or ownership data'). It is reasonably distinct from sibling tools like normalize-url and browser-url-ok, though it does not explicitly clarify that only the 'host' parameter is relevant despite the schema containing many unrelated fields.

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. The phrase 'without WHOIS or ownership data' hints at a use case, but no sibling tool or condition is named, and there is no 'use X instead when...' guidance for an agent to follow.

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 disclosure burden and does state that the request uses HEAD and returns only the status, which is a meaningful behavioral hint. It does not describe response format, redirect handling, or failure behavior, leaving some ambiguity for a tool with no output 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?

One tightly front-loaded sentence with no filler: it opens with the verb, states the resource, and closes with the output scope. Every word contributes.

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, no annotations, and a large sibling set, a single sentence about URL HEAD requests is insufficient. It does not explain how the other parameters relate, what a status result looks like, or when to prefer this tool over web-fetch or browser-url-ok.

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 already has a descriptive purpose and discard behavior. The description adds only a 'public' constraint to the URL, while leaving the other eight optional parameters unaddressed.

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

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

The description names a precise HTTP method (HEAD), a specific resource (a public URL), and the exact output (status only). This is enough to separate it from siblings such as web-fetch or browser-url-ok without opening schemas.

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 'return status only' implies this is the tool to choose when the agent needs just an HTTP status rather than content, and 'public URL' scopes it to public targets. However, it does not explicitly name alternatives or give when-not-to-use guidance among the many sibling tools.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It only reveals that the path is discarded; it does not state whether the tool is read-only, what it returns, whether it makes network requests, or how invalid inputs are handled.

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

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

The description is extremely concise and front-loaded, with no filler words. It is structurally efficient, though arguably too terse for a tool with nine 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 no annotations, no output schema, nine optional parameters, and many sibling tools, the description is far from complete. An agent would have to guess about return values, parameter selection, and behavior on invalid or non-Figma URLs.

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 Figma-specific meaning to the `url` parameter and confirms that `path` is ignored, but with nine optional parameters it does not clearly map which inputs are relevant or warn that most are 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 specific verb and resource: 'Parse a Figma file URL.' This clearly distinguishes the tool from generic URL tools like normalize-url or web-fetch. However, 'Path discarded' is ambiguous about whether it refers to the URL path or the path parameter, and it does not clarify whether the tool validates or extracts.

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 for Figma file URLs, which provides some context for selection. But it gives no explicit when-to-use/when-not-to-use guidance or alternatives among the many sibling URL and 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?

With annotations absent, the description carries the full behavioral burden. It does disclose one important behavior, 'No disk access,' which is useful. But it omits what criteria determine a 'safe' path, what the return value looks like, and whether other parameters affect behavior.

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

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

Two short sentences with no filler; the core intent is front-loaded. The 'No disk access' clause is a useful behavioral qualifier. It loses one point because the brevity sacrifices essential context that the schema and scope require.

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 annotations, no output schema, and multiple siblings, a two-sentence description is inadequate. It fails to explain what 'safe' means, which parameters are relevant, how results are returned, and when to choose this over related validators.

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, so each parameter is already documented. The description adds no parameter-level meaning and does not clarify why fields like url, city, feed, host, or json belong in a path-safety tool. Baseline 3 is appropriate because the schema carries the documentation load.

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: 'Check whether a path looks safe.' It is not a tautology and mentions a key constraint, 'No disk access.' However, it does not define what 'safe' means, and the 9-parameter input schema is misleadingly generic, making the tool's actual scope 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 this tool is for path safety validation, but provides no guidance on when to use it versus sibling tools like browser-url-ok, normalize-url, or validate-json. There are no when-to-use instructions, exclusions, or alternative routing cues.

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 mentions an external service and implies a read-only lookup, but it does not disclose failure modes, rate limits, return format, or whether inputs are discarded after the call.

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

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

The description is a single front-loaded sentence with no filler, so it is concise. However, it is under-specified: the one sentence does not use the available opportunity to add important invocation context.

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

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

For a tool with 9 optional parameters, no required fields, and no output schema, this description is materially incomplete. It does not tell the agent which parameter carries the place, what the output looks like, or how Open-Meteo should be queried.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning and fails to map 'a place' to any specific parameter such as city, but the schema itself already documents all parameters.

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

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

The description clearly identifies the tool's output (latitude and longitude) and its backend service (Open-Meteo), so an agent can infer the basic purpose. However, it lacks an explicit verb and does not differentiate from siblings like weather-hint or timezone, and 'place' is not tied to any schema 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 on when to use this tool versus alternatives such as weather-hint, timezone, or fetch-status. The only implied trigger is needing coordinates, but no exclusions or preferred contexts are stated.

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

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

No annotations are provided, so the description carries the full transparency burden. It only says 'parse', but does not disclose the return format, behavior on malformed or non-GitHub URLs, or whether the many other parameters are ignored or discarded. The read-only intent is implied, not meaningfully 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 a single, front-loaded sentence with no filler, which is excellent for brevity. It is so terse, however, that it omits usage and behavioral context an agent would benefit from, so it is not a perfect 5.

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

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

With nine optional parameters, no annotations, and no output schema, one sentence is insufficient context. The return value, error behavior, and relevance of the other parameters are completely unexplained, leaving an agent to guess 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 100%, so the baseline is 3. The description adds no per-parameter detail beyond the schema; it only hints at the overall purpose. An agent still has to infer that the relevant parameter is likely 'url' and that the other eight parameters are not central to the operation.

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

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

The description names a specific verb ('parse'), a specific resource ('GitHub URL'), and the expected extracted result ('owner and repo'). This clearly distinguishes it from sibling shape tools such as figma-url-shape or jira-key-shape without requiring the schema to be opened.

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 selection guidance is implied by the mention of 'GitHub URL', which suggests when this tool is relevant. However, there is no explicit when-to-use or when-not-to-use guidance, no mention of alternatives like normalize-url or browser-url-ok, and no 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?

With no annotations, the description carries the full burden. It does disclose a key behavioral trait: the tool produces only a count and discards titles. However, it does not describe data source behavior, freshness, network dependency, or error conditions, 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 two short sentences with the action front-loaded and no filler. Every word adds value: the purpose is stated first, and the important behavioral caveat about titles is included.

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, read-only count tool with no required parameters, the description is largely complete. It states the action and implies the return value is a count. However, the absence of annotations and an output schema, plus 9 optional parameters, leaves minor ambiguity about whether a caller should provide a feed or no parameters at all.

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

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

The schema has 100% description coverage, so the baseline is 3. The description adds no additional parameter-level guidance beyond what the schema already provides. 'Titles discarded' mirrors the feed parameter description but does not clarify which of the 9 optional parameters should be supplied, if any.

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: 'Count current Hacker News front-page stories.' It also adds a clarifying boundary, 'Titles discarded,' which distinguishes this tool from fetch or retrieval tools that would return story content. This is specific enough to differentiate it from siblings like web-fetch or fetch-status.

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

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

The intended use is implied clearly: use this tool when a count of current Hacker News front-page stories is needed. However, it does not explicitly mention alternatives, exclusions, or when not to use it, leaving some routing decisions to inference.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior, but it only describes content ('Common IANA timezone names'), not what happens when the tool is invoked. It does not mention whether this is a read-only lookup, whether results are returned, or that the passed values are reportedly discarded, leaving the tool's behavior opaque.

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

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

The text is short and free of filler, but it is a fragment rather than a sentence with a verb, and it omits essential operational context. This is under-specification rather than effective 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?

Given 9 optional parameters, no annotations, and no output schema, the description is far too sparse. It does not explain return values, side effects, how parameters relate to the tool's purpose, or how this tool should be invoked relative to the many sibling shape/time 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?

Although the schema descriptions cover 100% of parameters, the tool description points to IANA timezone names while the schema contains unrelated parameters such as ref, url, city, feed, host, json, and path—with no timezone parameter at all. This mismatch actively confuses rather than helps an agent map the description to the 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 is a noun phrase ('Common IANA timezone names for clock calls') with no operation verb, so it does not state what the tool does—returns, lists, validates, or stores. It mostly restates the tool name ('iana-zones') and, alongside siblings like 'timezone' and 'utc-time', does not clearly distinguish itself.

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?

It gives a vague purpose ('for clock calls') that implies use when working with clock/timezone tools, but it never explicitly says when to use this tool versus alternatives such as 'timezone' or 'utc-time'. No exclusions, prerequisites, or alternative routing 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 conveys that the tool performs a public network fetch and returns only group counts, which is useful context. However, with no annotations, the description still doesn't disclose failure behavior, robots.txt parsing specifics, rate limits, or what happens when the target is 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?

The description is one tightly written sentence with no filler. It clearly front-loads the tool's behavior and output scope.

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, this description is far too thin. It does not explain which parameters are relevant, how the robots.txt target is selected, what 'group counts' means exactly, or what the return value 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?

Although the schema has 100% parameter description coverage, those descriptions are completely misaligned with the tool's stated purpose. Params like 'Git ref name', 'City name', and 'Search text' are described as discarded after unrelated checks, and no parameter is explicitly described as the robots.txt URL or host. An agent cannot determine which parameter to supply to fetch the intended robots.txt.

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 specific resource ('a public robots.txt'), and a specific output ('return group counts only'). This gives a reasonably clear picture of what the tool does and somewhat distinguishes it from generic fetchers like web-fetch, but it doesn't clarify how the input parameters relate to this 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 implies the tool should be used when an agent needs robots.txt group counts, but it provides no explicit guidance about when to choose this over sibling tools like web-fetch or fetch-status. No alternatives or exclusions are mentioned.

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

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

There are no annotations, so the description carries the burden. 'Key discarded' explicitly signals no persistence, which is useful, but the description does not disclose return behavior, error handling, or what 'shape' means. It offers only a minimal statelessness hint without enough operational detail.

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

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

Two short sentences with no filler; the purpose is front-loaded. However, the extreme brevity borders on under-specification, so it is concise but not fully developed.

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 output schema, and no annotations, this definition is not complete enough to invoke correctly. It never says which parameter should hold the Jira key or what the result looks like. The mismatch between the tool's stated purpose and its generic schema makes the description nearly unusable.

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 does not connect the Jira key to any of the nine parameters. The schema descriptions (e.g., 'Git ref name', 'HTTPS URL to normalize or cite') are unrelated to Jira keys, so the description fails to add the needed mapping and leaves invocation 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?

States a specific verb and resource: 'Check a Jira issue key shape.' This is enough to distinguish it from sibling *-shape tools by resource, though it doesn't name alternatives or define the shape. The 'Key discarded' clause is confusing because no schema parameter is called 'key'.

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 choose this tool over domain-shape, github-repo-shape, or validate-json. The description implies a validation use case but gives no context, preconditions, or exclusions. An agent has to infer usage 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?

The description discloses that the body is discarded and that only the HTTP status is returned, which is a useful behavioral guarantee. However, with no annotations provided, it does not mention network behavior, redirects, error handling, or whether the request 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 front-loaded sentence that conveys the main outcome and an important behavioral detail without wasted words. It is concise, but the brevity comes at the cost of needed invocation context.

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

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

With 9 optional parameters, no required parameters, no output schema, and several closely related sibling tools, this one-sentence description is insufficient. It does not specify which parameter to pass, what happens if none are supplied, the return format, or how this tool differs operationally from fetch-status and browser-url-ok.

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

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

Although the schema has 100% description coverage, the tool description's central concept, a 'public library docs URL', is not mapped to any parameter. The only URL-like param, 'url', is described as 'HTTPS URL to normalize or cite', which does not clearly align with the stated HTTP-status purpose, leaving the agent to guess.

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 clear action and resource: returning the HTTP status for a public library docs URL, with the body discarded. It is distinct from generic fetch/status tools, though it does not explicitly name a sibling or resolve the ambiguity of which URL parameter to use.

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 choose this tool over sibling tools like fetch-status, browser-url-ok, or web-fetch. The phrase 'Body discarded' hints at a use case, but there are no explicit when-to-use or when-not-to-use instructions.

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 only says 'Values discarded', but does not disclose return format, behavior on invalid JSON, whether the count is top-level or recursive, or any side effects on memory state.

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

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

The description is extremely concise: two short sentences with no filler. Both sentences add meaning, and the core purpose is front-loaded.

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

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

Given no output schema, no annotations, and a 9-parameter input schema, the description is not complete enough. It does not state the return value, which parameter is the JSON input, or how to handle malformed JSON, leaving an agent uncertain how to invoke the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds that values are discarded but does not clarify which parameter (e.g., 'json') should contain the JSON object, and the schema's own description for 'json' mentions validation rather than key counting.

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

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

The description states a specific action ('Count keys') and resource ('JSON object'), and 'Values discarded' clarifies that values are irrelevant. It is distinct from siblings like validate-json, 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?

The description gives no guidance on when to use this tool versus validate-json, search-query-len, or other siblings. It does not state prerequisites, edge cases, 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 must carry behavioral disclosure. It does disclose that query strings and fragments are dropped, which is useful. However, it does not explain the odd 9-parameter schema where most fields are labeled 'discarded', nor does it describe behavior for invalid URLs or the exact return shape.

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 key transformation behavior is stated directly.

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 required fields, no annotations, and no output schema, this description is incomplete. It leaves the agent unsure which parameter drives the call, what the return format is, and why most schema fields are described as discarded.

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 minimal parameter meaning beyond mentioning URL components, but it does not clarify the relationship between the `url` parameter and the several 'discarded' parameters. The 'Query and fragment are dropped' line could even be confused with the `query` parameter.

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

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

The description states a specific verb and result: 'Return origin, host, and path for a URL. Query and fragment are dropped.' It clearly describes the tool's function and distinguishes it from URL-checking or fetching siblings by focusing on normalized components.

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

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

There is no guidance about when to use this tool instead of siblings like `browser-url-ok`, `web-fetch`, or `citation`. The description does not mention which parameter should be provided, whether `url` is the intended primary input, or what conditions make this 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?

With no annotations provided, the description carries the full behavioral disclosure burden. It discloses one useful trait—'No browser is launched'—but fails to mention whether a network request is made, whether data is only checked and discarded, or what the success/failure response looks like. The parameter descriptions hint at 'discarded after the shape check,' but the main description does not explain this behavior coherently.

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-loads the core action, with 'No browser is launched' adding a valuable exclusion. However, it is under-specified to the point of being incomplete, and the two sentences do not adequately cover the tool's complexity (seven parameters, no output schema). Thus it is concise but not effectively structured for agent use.

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

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

Given seven heterogeneous parameters, no required fields, no output schema, and no annotations, this description is grossly incomplete. An agent cannot determine what to pass, whether to pass one or multiple of the parameters, what the tool returns, or what side effects might occur. The description leaves too many critical invocation details 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?

The input schema provides descriptions for all seven parameters, so the baseline is 3; however, these descriptions are terse and ambiguous ('discarded after the shape check'). The tool description does not clarify which parameters are relevant to 'checking whether a URL can be opened,' nor does it indicate required versus optional parameters. Since the schema already carries the burden of parameter names and short descriptions, the description adds no additional 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 states a specific verb and resource: 'Check whether a URL can be opened.' It also distinguishes itself from a browser-based alternative with 'No browser is launched,' which clearly separates it from siblings like browser-url-ok. However, it does not define what 'opened' means (e.g., network reachability vs. syntactic validity), so it is not fully precise.

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

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

The description offers no explicit guidance on when to use this tool versus alternatives such as browser-url-ok, normalize-url, or fetch-status. It only mentions that no browser is launched, which implies a lightweight check, but does not state conditions or exclusions. The presence of heterogeneous parameters (city, feed, json, path) further muddies the intended use case without any routing 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It does disclose that the query is discarded, which is a useful side-effect hint. But it says nothing about return values, whether other accepted parameters have side effects, or why the schema describes 'shape check' behavior that the description never acknowledges. 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 short and front-loaded with no filler, and each sentence carries information. However, for a tool with nine optional parameters and no annotations or output schema, it is under-sized and omits necessary scope, so it is not appropriately sized. This is conciseness at the cost of completeness rather than effective efficiency.

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 context is complex: nine optional parameters, no annotations, and no output schema. The description fails to mention eight of those parameters, does not state what the tool returns (e.g., a number or validation status), and leaves the mismatch between 'count a search query' and the URL/city/JSON/host fields unresolved. An agent cannot confidently select or correctly invoke this tool based on this 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?

Schema description coverage is 100%, so the baseline is 3. The description adds no per-parameter meaning beyond the schema; it only refers to the query concept while ignoring the eight other documented parameters. Since the schema already describes each parameter sufficiently, the description need not compensate, but it also contributes nothing extra.

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

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

The description states a concrete action ('Count characters in a search query') and one behavior ('Query discarded'), so it is not a mere restatement of the name. However, it is misleadingly narrow: the input schema exposes eight other heterogeneous parameters (url, city, feed, json, path, zone, host, ref) and the description never explains their relationship to the tool. It also does nothing to distinguish this tool from similar count/check siblings like memory-key-count or hn-front-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?

No when-to-use, when-not-to-use, prerequisite, or alternative guidance is provided. The only inferred usage is that this tool is for measuring search-query length, which is implied by the name rather than explicitly recommended. Given the long sibling list, an agent receives no help choosing this tool over related 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 provided, so the description carries the full burden of behavioral disclosure. Saying the catalog is 'short' and contains 'common' codes gives a little scope information, but it does not say whether the tool performs a lookup, validates a status, returns a list, or has any side effects.

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

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

The description is short and free of filler, but it is under-specified rather than genuinely informative. A single noun phrase with no actionable guidance does not earn its place as a useful tool description.

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

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

With no output schema, no annotations, nine parameters, and no explanation of how the catalog is consumed, the description is inadequate for an agent to select and invoke the tool correctly. The known fact that it relates to HTTP status codes is not enough.

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

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

Schema description coverage is 100%, so each parameter is already described in the schema. The description itself adds no parameter meaning, but the baseline of 3 applies because the schema handles the documentation burden.

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

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

The description says the tool is a 'Short catalog of common HTTP status codes,' which names a resource but does not specify a verb or what operation the agent can perform. It is close to a restatement of the name and does not distinguish the tool from siblings like fetch-status or web-fetch.

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

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

There is no guidance about when to use this tool, what kinds of inputs are appropriate, or how it compares with alternatives. The sibling list includes many potentially related tools, but the description gives no routing or selection criteria.

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

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

With no annotations, the description carries the burden of behavioral disclosure. 'Prompt discarded' clearly signals that the user prompt will not be used, and the schema fields reinforce that most inputs are discarded or only shape-checked. It does not discuss side effects or errors, but the main surprising 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 the primary action front-loaded and no filler. The second sentence adds the critical discard behavior without redundancy.

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

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

Given nine optional parameters and no output schema, the description is adequate for a simple template-returning tool but leaves ambiguity about whether any argument should be passed and what the returned template contains. The schema's parameter descriptions compensate partially, not fully.

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 all nine parameters are already individually documented. The description adds only the tool-level 'Prompt discarded' note and does not clarify how the heterogeneous parameters relate to the returned template, which keeps this at the baseline score.

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

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

The first sentence states a specific verb and deliverable: 'Return a three-step thinking template.' This makes the core action clear. It does not explicitly differentiate from sibling tools, though none is obviously analogous.

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, and no alternative tool is named. 'Prompt discarded' is a caution about behavior, not a selection rule, so an agent has little basis for choosing this tool over its 26 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 must signal behavior itself. The phrase 'current time' implies a read-only lookup, but the description does not disclose the output format, behavior for invalid IANA names, or how the many unrelated schema properties relate to the 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?

The description is a single, front-loaded sentence with no filler. It is easy to scan and every word contributes to the core 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?

With no output schema and no annotations, the description leaves important gaps: it does not state what the response contains, whether the zone must be an exact IANA identifier, or that the other eight input parameters are essentially irrelevant to this lookup.

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, including `zone`. The description adds little beyond mapping the concept of a 'named IANA timezone' to the `zone` 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 as a named IANA timezone and states the tool's purpose as reporting the current time in it. It distinguishes this from siblings like `utc-time` and `iana-zones`, though it lacks an explicit verb such as 'Get' or 'Returns'.

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

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

Usage is implied: an agent should use this when it needs the current time for a specific IANA timezone. However, there is no explicit guidance about when to prefer `utc-time` or `iana-zones`, and no exclusions or alternative conditions are stated.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It does not state whether the tool has side effects, ignores all input parameters, or what exact format the timestamp uses. The schema hints that many parameters are discarded, but the description itself adds no 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 a single, front-loaded sentence with no fluff. It is appropriately sized for a trivial tool, though it would benefit from a small amount of additional context about output format.

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 the description does not explain the return value's format (e.g., ISO 8601 string, epoch seconds). The tool's input schema contains many seemingly unrelated parameters, and the description does not clarify why they exist or that they are effectively ignored.

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

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

All seven parameters have schema descriptions, so schema coverage is high. The description itself adds no parameter information, but the schema already documents each parameter, including notes about values being discarded after the check or call.

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

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

The description says 'Current UTC timestamp,' which clearly communicates that the tool returns the current UTC time. It is a clear purpose but does not explicitly distinguish itself from sibling 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?

There is no guidance about when to use this tool versus alternatives such as timezone or iana-zones. The description implies a use case—getting the current UTC time—but offers no exclusions, prerequisites, or comparison to sibling tools.

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

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

With no annotations provided, the description carries the disclosure burden. It does add one useful behavioral fact: the body is discarded, implying no persistence. However, it does not describe what the tool returns, whether it performs any network access, or how the unrelated parameters are treated.

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, front-loads the core action, and contains no filler. Both sentences earn their place by stating what the tool does and that the input is discarded.

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

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

Despite a complete schema, the tool has nine optional parameters, no output schema, and no annotation coverage. The description does not connect 'body' to the parameter list or indicate what a successful or failed validation looks like, so an agent is not fully equipped to invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters. The tool description adds no parameter-level meaning and creates mild ambiguity by referring to a 'body' that does not appear as a parameter name, leaving the agent to infer that 'json' is the intended input.

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: checks whether a body is valid JSON, and it notes the body is discarded. This is clearer than a tautology and distinguishes the tool from sibling URL/file/jira shape checkers, though 'body' is never explicitly mapped to the 'json' 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 versus alternatives, no exclusions, and no mention of related tools. An agent is left to infer the appropriate context from the tool 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 full burden of disclosure. It identifies a live data source but does not mention read-only behavior, caching, units, error handling, or the fact that the input schema allows many non-weather parameters that are discarded. It is not contradictory, but it is thin.

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

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

The description is a single front-loaded sentence with no filler, making it easy to scan. It is concise to the point of being under-specified for a 9-parameter tool, but structurally it is well-formed.

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 9 optional parameters, 100% schema coverage, no output schema, and no annotations, the one-sentence description is insufficient. It does not explain return format (e.g., units), what happens when city is missing, which parameters to ignore, or how this relates to sibling 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 description coverage is 100%, so the baseline applies: the input schema already documents every parameter. The description adds the Open-Meteo source and ties 'city' to temperature, but does not clarify which of the other eight optional parameters are relevant or how they interact; overall it neither exceeds nor badly fails the 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?

The description states a specific resource ('current temperature for a city') and names the data provider (Open-Meteo), which makes the tool's core function clear. It lacks an explicit verb like 'get' or 'fetch', but the noun phrase is unambiguous and differentiates it from sibling hint tools such as geo-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 choose this tool over alternatives, no exclusions, and no indication that only the 'city' parameter should be supplied. The context implies weather lookups but never states the selection criteria.

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

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

With no annotations present, the description must carry the behavioral disclosure burden. It does add one useful trait – 'Body discarded' – and scopes input to 'public URL.' But it completely omits the fact that non-URL parameters (ref, city, json, feed, host, path) are accepted and discarded, so the agent is unaware of these behaviors and may be misled about what the tool can handle.

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

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

The description is a single, front-loaded sentence with no wasted words: it states the expected output and the body-discard behavior upfront. The brevity is structurally good, though it contributes to the overall incompleteness.

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 a 7-parameter schema, no output schema, and no annotations, a one-sentence description is clearly insufficient. The agent is left without details on return shape, error cases, which parameter to use when, or the purpose of the many non-URL inputs. The current description only covers a narrow slice of the tool's actual 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 input schema already provides descriptions for every parameter (100% coverage), including notes like 'discarded after the shape check,' so the baseline is 3. The description adds no extra parameter-level meaning; it only reinforces the URL path, and could even mislead an agent into ignoring the other 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 concrete result – 'HTTP status and content type for a public URL' – and adds the behavior 'Body discarded.' However, it captures only one of the many input types visible in the schema (ref, city, json, etc.), so the purpose statement is incomplete and not a true representation of the tool's full scope. It also fails to differentiate from siblings like fetch-status or normalize-url, since nothing indicates what makes this tool's status/content-type result distinct.

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

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

The description gives no guidance on when to use this tool versus any of its many siblings, such as fetch-status, browser-url-ok, or normalize-url. There is no mention of conditions, exclusions, or alternatives, leaving the agent to infer the appropriate context on its own.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only mentions that the title is discarded after the call, which hints at data handling but leaves out network behavior, side effects, or result semantics. The discard note is also 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 description is efficient at one sentence, but it under-specifies the tool to the point of being unhelpful. The single sentence omits essential operational details, so it is not appropriately sized for a tool with a complex schema.

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

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

Given seven parameters, no output schema, and no annotations, a one-sentence purpose statement is far from complete. An agent cannot determine which parameter to populate or what the check result looks like, making the tool effectively uncallable in practice.

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 parameters, but the tool description introduces a 'Wikipedia title' concept without mapping it to any of the seven schema parameters. This actively misleads rather than enhancing what the schema already communicates, leaving the agent unable to determine which input represents the title.

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

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

The description states a clear verb ('Check') and resource ('whether a Wikipedia title exists'), making the tool's core function understandable. It does not explicitly differentiate from sibling tools like browser-url-ok or playwright-url-ok, but the specific subject matter gives adequate 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?

There is no guidance on when to use this tool versus alternatives, nor any mention of prerequisites or conditions. The one-line description provides no context about which sibling tools it complements or when an agent should select it.

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