ISO country LS

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

With no annotations, the description carries the transparency burden. It discloses that task text is discarded and that the result is a bundle of setup/metadata rather than a live task result. However, it does not explicitly state read-only behavior, network access, cost implications, or error behavior, so the agent must infer the safety profile.

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 crisp sentence plus a short privacy/behavior note. It front-loads the action and output artifacts and contains no filler or redundant restatement of the tool name.

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

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

The mismatch between a 'find a gateway' purpose and nine optional parameters is not resolved: it is unclear which parameter, if any, should be passed or how the returned CLI setup/skill file is structured. With no output schema, no annotations, and no parameter-selection guidance, an agent would be guessing at the invocation contract.

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

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

Schema description coverage is 100%, so the schema already documents each parameter and its discard/no-disk-access behavior. The tool description adds no parameter-level meaning beyond the repeated 'Task text discarded' concept. Baseline 3 is appropriate because the schema carries the parameter-semantics 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 uses a specific verb ('Find') and a named resource ('public pay-per-call tool gateway (Monid)'), then lists concrete output artifacts. This clearly distinguishes the tool from all siblings, none of which mention CLI setup, skill files, or remote MCP hops.

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 stated purpose gives a clear trigger: use this when the agent needs Monid's CLI setup, how-it-works, skill file, or remote MCP hops. The 'Task text discarded' clause is an implicit exclusion, signaling this is not a task-execution tool. It does not name a sibling alternative, but no sibling covers this function.

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 entire behavioral burden, but it only reveals that no browser is launched. It does not clarify what 'can be opened' means, whether any network request is made, what is returned, or how the many unrelated-looking parameters 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: two short sentences, no filler, and the primary purpose is stated first. The additional behavioral note about not launching a browser earns its place by clarifying the tool's non-destructive nature.

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 nine optional parameters and no output schema, yet the description offers no invocation pattern, return format, or explanation of how the parameters relate to the URL check. The schema documents each parameter, but an agent still lacks enough context to know how to call this 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 the individual parameter descriptions already document each field. The tool description adds little parameter-level meaning beyond singling out URL-related checking, but it does not need to compensate because the schema is already thorough.

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'), which gives a basic sense of the tool's purpose. It does not differentiate this tool from siblings like playwright-url-ok or normalize-url, but it is more than merely restating the tool name.

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 playwright-url-ok, normalize-url, or fetch-status. The phrase 'No browser is launched' implies a non-browser check, but no explicit conditions or exclusions are provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says the expression is discarded; it does not state whether evaluation is side-effect free, what is returned, or whether auth, rate limits, or other constraints apply.

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

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

The description is only two short sentences with no filler, and the action is front-loaded. The second sentence is compact but cryptic, slightly reducing overall clarity.

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

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

With nine optional parameters, no required fields, no output schema, and no annotations, the description leaves the calling contract entirely unspecified. It does not explain how any of ref, url, city, feed, host, json, path, zone, or query relates to arithmetic evaluation, making the tool effectively uncallable.

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 nine schema properties have descriptions, so the baseline would be 3, but none of them is an arithmetic expression or operand, and additionalProperties is false. The description's 'a+b style arithmetic' and 'Expression' have no corresponding property, so an agent cannot determine which parameter to populate to invoke the tool.

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

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

The first sentence states a specific verb ('Evaluate') and resource ('a+b style arithmetic'), so the intended operation is identifiable and not merely a restatement of the tool name. However, the second sentence references an 'Expression' that has no corresponding field in the input schema, which slightly undermines clarity.

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

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

There is no guidance about when to use this tool versus any sibling tool, no prerequisites, and no exclusions. The only usage hint is the action itself, which is implied rather than explicitly stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does add one meaningful behavioral trait: page content is not stored, which is a privacy-related guarantee. However, it does not disclose other important behaviors such as whether any input is retained, whether network access is required, or whether there are side effects beyond returning results.

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

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

The description is two short sentences with no filler. The primary function is stated first, and the key behavioral caveat about not storing content is included second. 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?

Given the rich input schema with 9 optional parameters and no output schema, the description is somewhat thin. It clearly states the return values, which is good, but it does not clarify that only the url parameter is relevant or that the other parameters are ignored/discarded. The schema helps, but an agent could still be uncertain about which parameters matter for a citation call.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the tool description only mentions 'URL'. The schema already documents each parameter, including which values are discarded. The description adds little semantic meaning beyond identifying url as the key 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 ('Return') and a precise result set: host, scheme, and HTTP status for a URL. This clearly distinguishes the tool from siblings like normalize-url or fetch-status, which focus on narrower or different outputs. The additional 'Page content is not stored' clause further separates it from web-fetch or browser-url-ok.

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

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

The description implies the tool should be used when an agent needs host, scheme, and HTTP status for a URL. However, it does not explicitly state when to prefer this tool over sibling tools like fetch-status or normalize-url, nor does it mention any exclusions or alternative routing. Usage context is present but only by 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 carries the full burden. It does disclose a meaningful behavioral trait—'No identifiers are retained'—and the schema reinforces this with 'discarded after' notes, but it does not clarify whether the tool is read-only, performs network calls, or has other 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 two sentences are short, front-loaded with purpose, and contain no filler. The brevity is efficient, even though it contributes to under-specification.

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

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

For a 9-parameter tool with no annotations and no output schema, the description lacks the return shape, the meaning of 'classification', and any relationship to the sibling tools. The schema's disposal notes are helpful but do not complete the picture.

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

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

Schema description coverage is 100%, with each of the 9 parameters individually explained, so the baseline applies. The tool description itself adds no parameter-level meaning beyond what the schema already provides.

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

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

The description states a verb and object ('Show how this request is classified'), so it is not a pure tautology. However, it leaves the classification scheme undefined and does not differentiate the tool from the many sibling shape-check tools.

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

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

There is no when-to-use guidance, no exclusions, and no mention of alternatives among the sibling tools. The second sentence is a privacy note, not a usage condition.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the core transformation and one negative ('without WHOIS or ownership data'), without mentioning return format, side effects, discarded inputs, or error 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 a single active sentence with no filler, and the main limitation is woven into the first clause. It is appropriately sized and 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?

Despite the concise sentence, the tool has 9 optional parameters and no output schema or annotations, so an agent cannot tell which parameter to pass or what the tool will return. The description does not compensate for that gap, making it incomplete 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 coverage is 100%, so the baseline is met without extra parameter explanation. However, the description adds no parameter-level guidance beyond implying that 'host' is relevant, and the schema contains eight unrelated optional parameters that could confuse an agent.

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 ('split'), a specific resource ('hostname'), and a clear output ('labels'). It also explicitly excludes WHOIS/ownership data, which helps distinguish it from enrichment or domain-information tools among the 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?

There is no explicit 'use when' or named alternative, but the wording implies the tool is for hostname splitting/shape tasks and not for WHOIS/ownership lookups. This is minimal implied usage guidance; it does not direct the agent away from sibling shape/validation 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, the description carries the behavioral transparency burden. It clearly discloses the HTTP method (HEAD) and the narrow output scope ('status only'), which is meaningful and transparent for a read-only check. It does not mention timeout, redirect, or error behavior, but the core side-effect-free behavior is adequately conveyed.

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

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

The description is one short, front-loaded sentence with no wasted words. It is concise, but perhaps too terse for a tool with nine parameters and many siblings; still, the core behavior is 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?

Given the absence of annotations, no output schema, nine parameters, and a large sibling set, the one-line description is insufficient for an agent to make robust decisions. It does not explain the other parameter modes, the exact response shape, failure behavior, or how to choose between this and the many similar URL-checking siblings.

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

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

The input schema has 100% description coverage with detailed explanations for all nine parameters, so the baseline is 3 even though the main description adds nothing about parameters. The description's single-minded focus on 'a public URL' does not explain how city, json, path, feed, or query relate to fetching status, but the schema descriptions fill that gap.

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 and scope: 'HEAD a public URL and return status only.' This clearly distinguishes the tool from content-fetching tools like web-fetch and is more precise than the bare tool name. However, it does not acknowledge the schema's other parameter modes, so the stated purpose is narrower than the input surface suggests.

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

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

No explicit guidance is given for when to use this tool versus its many siblings such as browser-url-ok, playwright-url-ok, web-fetch, or inspect-robots. The HTTP HEAD mention implies a lightweight status check, but the description never states exclusions or directs the agent to an alternative when content or 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, the description carries the full burden of explaining behavior. The only disclosed behavioral trait is 'Path discarded,' which tells the agent the path component is ignored. It does not mention what the parse returns, how invalid Figma URLs are handled, whether any normalization occurs, or confirm 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 very concise and front-loaded: 'Parse a Figma file URL' immediately communicates the core purpose. 'Path discarded' is an additional behavioral note with no wasted words. It is under-specified but not verbose.

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

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

The tool has nine optional parameters, no output schema, and no annotations, so the description needed to explain which parameter to use and what the outcome looks like. It does neither. The agent must infer that 'url' is the relevant input and guess at the return behavior.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds some meaning by clarifying that the URL should be a Figma file URL, which the generic schema description for 'url' does not convey. However, it does not identify which of the nine optional parameters to populate, and several schema properties are unrelated to Figma URLs.

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 resource ('Figma file URL') and a specific action ('Parse'), which distinguishes it from sibling shape tools like github-repo-shape or jira-key-shape. However, 'parse' is somewhat ambiguous because it doesn't state whether the tool validates, normalizes, or extracts components; 'Path discarded' adds detail but not full clarity.

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

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

No explicit when-to-use or when-not-to-use guidance is present. The description does not name alternatives or explain conditions for selecting this tool over similar URL/shape tools; the agent is left to infer usage from the tool name and sibling list.

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 must carry the behavioral transparency burden. 'No disk access' is a meaningful safety disclosure beyond the name, indicating no filesystem side effects. However, it does not explain the return value, error behavior, or what 'looks safe' covers.

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

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

The description is only two short sentences with no filler. The core purpose is front-loaded, and 'No disk access' follows as a key behavioral note. Every word contributes 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?

Despite the schema being self-explanatory for individual parameters, the tool accepts nine optional parameters and has no output schema or annotations. The description does not explain why unrelated parameters exist, whether 'path' is effectively required, or what response the caller should expect, making correct invocation underspecified.

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 every parameter, including 'path' as 'File path to check'. The tool description adds no additional parameter-level meaning, matching the baseline score of 3.

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 resource: 'Check whether a path looks safe.' This is not a tautology and it distinguishes path-checking from the many sibling URL/title/shape validators. The main ambiguity is what exactly 'safe' means, which prevents 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?

The description implies the tool is for validating path safety without touching disk, which is a reasonable usage cue. However, it does not name any alternatives or state when not to use it, so the guidance is only implicit rather than explicit.

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

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

With no annotations, the description must carry the behavioral transparency burden, but it only mentions the external dependency 'via Open-Meteo'. It does not state whether the operation is read-only, how failures are handled, or that inputs are discarded, making side effects and error behavior unclear.

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 easy to read, but it is under-specified rather than efficiently complete. It omits critical operational details 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?

For a tool with 9 optional parameters, no required parameters, and no output schema, this description is insufficient. It lacks input selection guidance, return format, and failure behavior, so an agent cannot reliably invoke it.

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

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

Although the schema describes all 9 parameters, the tool description does not map 'a place' to any specific parameter. The 'city' parameter is described as 'for a public weather hint', not as a geocoding input, so an agent cannot confidently determine what to pass.

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 latitude and longitude for a place via Open-Meteo, which is a specific and recognizable purpose. It does not explicitly differentiate from sibling tools, but the intended outcome is unambiguous.

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

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

The description gives no guidance on when to use this tool instead of alternatives like weather-hint or timezone. It also does not explain how to identify which input parameter should carry the 'place', leaving usage largely 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 carries the full burden for behavioral disclosure. 'Parse' implies a read-only, local operation rather than a mutation, and the schema clarifies that other fields are discarded. However, the description does not state whether the URL is fetched, how invalid URLs are handled, or exactly what result shape 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?

The description is a single clear sentence with no filler. It front-loads the core action and expected result, making it easy for an agent to quickly understand the tool's purpose.

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 parse tool, the description gives the essential purpose and result, and the schema explains the many discardable parameters. However, given nine optional parameters and no output schema, the description could more explicitly identify which parameter should be populated and what the owner/repo result 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?

Schema description coverage is 100%, so all nine parameters are already documented and the baseline is 3. The description adds only a little semantic value by clarifying that the relevant input is a GitHub URL and the extracted result is the owner and repo. It does not meaningfully elaborate on parameter usage beyond the schema.

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

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

The description states a specific action and resource: parse owner and repo from a GitHub URL. This clearly distinguishes it from sibling shape tools like figma-url-shape, domain-shape, and jira-key-shape without needing to inspect the schema.

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

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

The description makes the context clear: use this tool when the input is a GitHub URL and the needed result is owner and repo. It does not explicitly name alternatives or exclusions, but the GitHub-specific wording is enough to guide selection 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?

No annotations are present and the description does not state whether the tool is read-only, whether it performs network requests, or what side effects might occur. Counting front-page stories implies a read-only operation, but this is not explicit.

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 brief and easy to read, with no redundant filler. The 'Titles discarded' sentence is slightly ambiguous but still concise and does not waste words.

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

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

The description does not explain what the tool returns beyond implying a count, nor does it clarify how the provided parameters should be used. Given the mismatched parameter list, the context is incomplete for an agent to 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?

The nine parameters have descriptions that are entirely generic and mostly irrelevant to counting Hacker News front-page stories (e.g., Git ref, IANA timezone, file path, JSON text). Several parameters explicitly say they are 'discarded,' which creates confusion about why they exist in the schema at all.

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

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

The description clearly states the tool counts current Hacker News front-page stories, which is a specific action on a specific resource. The phrase 'Titles discarded' adds a small but relevant clarification that only the count 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?

No guidance is provided about when to use this tool versus the many sibling tools such as web-fetch, fetch-status, or browser-url-ok. The description does not mention prerequisites, intended scenarios, or whether it complements other 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 explaining behavior. It does not mention whether the tool is read-only, what it returns, what side effects occur, or how inputs are processed. Individual parameter descriptions mention 'discarded' and 'no disk access,' but tool-level behavior remains completely undisclosed.

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

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

The description is very short and free of fluff, but it is under-specified to the point of being a fragment rather than a useful sentence. It conveys almost no operational information, so its brevity does not serve the agent.

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 fields, no output schema, and no annotations, the description is far too thin. An agent cannot determine what meaningful inputs to provide or what response to expect, making the tool effectively uninvokable based on this definition 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 baseline is 3 even though the tool description adds no parameter-level meaning. The schema itself provides explicit descriptions for each parameter. However, the description does not explain why parameters like ref, url, city, feed, host, json, path, and query are relevant to an IANA-zones 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 is a noun phrase ('Common IANA timezone names for clock calls') with no verb stating what the tool does. It does not say whether the tool lists, validates, returns, or normalizes timezone names, and it largely restates the tool name. It also fails to distinguish itself from the sibling tool 'timezone'.

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

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

There is no guidance about when to use this tool versus alternatives. The only contextual hint is 'for clock calls,' but it does not explain when an agent should choose this over timezone, utc-time, or other sibling tools. No exclusions, prerequisites, or alternative conditions 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?

No annotations are provided, so the description must carry the behavioral disclosure burden. It mentions a network fetch and that only group counts are returned, but it does not disclose failure behavior, whether the fetch is read-only beyond implication, what 'group counts' includes, or that most schema 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 a single, front-loaded sentence with no filler. It communicates the core purpose and output scope efficiently.

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 required parameters, and no output schema, the description is too sparse. It does not identify the relevant input parameter, define what counts as a group, describe error handling, or distinguish behavior from sibling fetch/URL tools, making reliable invocation uncertain.

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 even with no parameter detail in the description. However, the description does not map the robots.txt URL to any of the nine optional parameters, and schema descriptions like 'HTTPS URL to normalize or cite' and 'Public hostname' create ambiguity about which field should be populated.

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: 'Fetch a public robots.txt' and narrows the output to 'group counts only'. This distinguishes it from generic fetch tools, though it does not explicitly separate it from web-fetch or fetch-status or state which parameter carries the robots.txt URL.

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

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

There is no guidance about when to use this tool versus alternatives like web-fetch, fetch-status, or normalize-url. The usage is only implied by the tool name and one-line description; no exclusions, prerequisites, or sibling comparisons 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 only behavioral hint is 'Key discarded', but the key is not a schema property, and the schema's own discard notes are attached to mismatched fields. With no annotations provided, the description carries the full burden of disclosing whether the tool is read-only, what it returns, or what it discards, and it does not do so.

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, with no filler words, and the intended purpose is front-loaded. As a concise statement it is efficient, though the brevity also contributes to the missing 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?

The definition is materially incomplete for invocation. An agent needs to know which schema property receives the Jira key and what constitutes a valid shape, but the description provides neither, and the schema appears to be an unrelated grab-bag of fields. This is not enough information to call 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?

All seven schema parameters have their own descriptions, so the baseline is 3. However, the tool description introduces a 'key' concept that does not correspond to any property, actively confusing parameter mapping. It adds no meaning to the actual parameters and undermines the schema descriptions by describing a parameter that does not exist.

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

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

The description says 'Check a Jira issue key shape', which at face value is a clear verb and object. However, it is misleading: the input schema contains no Jira key parameter, and its actual properties (ref, url, city, feed, host, json, path) are unrelated to that purpose. An agent cannot map the stated purpose to any available parameter, so the described functionality is not actually invocable as written.

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 sibling shape-validation tools like domain-shape, github-repo-shape, or wiki-title-ok. It also does not mention what kind of input qualifies as a Jira key or when this tool should be preferred over alternatives, leaving selection entirely 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?

The description explicitly says 'Body discarded,' which is a useful behavioral disclosure that goes beyond the schema. However, with no annotations, it does not disclose whether the operation is read-only, how redirects or errors are handled, or what happens with the many other input fields.

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

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

The description is two short sentences with no filler, and the core output (HTTP status) is front-loaded. It is concise but perhaps too sparse for a tool with nine optional parameters and no output schema.

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

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

For a tool with nine optional parameters, no output schema, and no annotations, the description is incomplete. It does not clarify which parameter an agent should supply, what the full response looks like, or why fields like city, feed, json, path, zone, and query are present.

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

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

Schema description coverage is 100%, so the baseline is 3 and the description is not required to repeat parameter details. Still, the description only loosely maps to the `url` parameter and gives no indication of how the remaining eight parameters relate to the tool's 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 concrete result type (HTTP status) and a resource type (public library docs URL), and it clarifies that the body is discarded. However, 'public library docs URL' is ambiguous, and the 9-parameter schema with fields like city, feed, json, path, zone, and query is not addressed, so the description does not fully convey the tool's actual scope. It also does not differentiate this tool from siblings 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?

There is no guidance on when to use this tool versus alternatives such as fetch-status, browser-url-ok, or normalize-url. The description does not mention how to choose among the nine optional parameters or whether one should be provided at a time.

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

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

No annotations are provided, so the description carries the full burden. 'Values discarded' is a real behavioral disclosure, but the description omits the return type, whether keys are counted at top level or recursively, error handling, and any side-effect or mutability information. This is thin for a description with zero annotation support.

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

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

The description is extremely concise and front-loaded with the action ('Count keys'), immediately followed by a clarifying constraint ('Values discarded'). Every word earns its place with no filler.

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

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

Despite full schema descriptions, there is no output schema and no annotations, and the description does not state what the tool returns or disambiguate which parameter should be treated as the object to count. An agent is left guessing between passing `json` as JSON text and supplying multiple optional keys as the object itself.

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 does not explicitly map the JSON object to the `json` parameter or clarify whether the count applies to the keys in the argument object or to the contents of the `json` string; parameter descriptions like 'JSON text to validate; discarded after the check' add ambiguity rather than resolving it.

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

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

The description states a specific operation ('Count keys') and a clear target ('JSON object'), plus a meaningful behavioral constraint ('Values discarded'). It is distinguishable from sibling validation/shape tools like validate-json because the focus is key counting rather than validation, though the 'memory' aspect in the tool name is left unexplained.

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 mention of what to do with empty objects or invalid JSON, and no exclusionary notes like 'use validate-json instead'. Usage has to be inferred entirely from the name and description.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal that query and fragment are dropped and that only origin, host, and path are returned, but it fails to state that the operation is read-only or that all parameters except 'url' are discarded, which is especially pertinent given the 9-parameter 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 two short sentences with no wasted words. The core behavior is front-loaded, and each sentence contributes a distinct piece of information: what is returned and what is removed.

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

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

Given 9 parameters, no annotations, and no output schema, the description is too sparse. It leaves unanswered questions about whether the other parameters are accepted, what happens on malformed URLs, and whether any network access or side effects occur.

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 modest value by indicating what the 'url' parameter produces (origin, host, path), but it does not clarify how the other parameters relate to the tool—even though their schema descriptions say they are discarded. An agent still must infer that 'url' is the primary 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 ('Return') and resource ('origin, host, and path for a URL'), and it specifies the transformation ('Query and fragment are dropped'). This clearly identifies what the tool does and distinguishes it from generic URL validators, though it does not explicitly contrast with sibling tools like browser-url-ok or figma-url-shape.

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

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

The description gives no guidance on when to use this tool versus alternatives such as web-fetch or domain-shape. It also does not mention that the other eight schema parameters are irrelevant to the URL normalization task, leaving an agent without direction on what to pass or what to avoid.

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

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

With no annotations, the description carries the transparency burden. It discloses one important behavior—no browser is launched—but does not explain what 'open' means, whether a network request is made, what side effects may occur, or what result 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?

Two short sentences, each earning its place: the core operation and the key behavioral caveat. There is no redundancy or filler.

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

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

For a tool with nine parameters, many siblings, and no output schema, this is under-specified. It does not describe the return value, how openability is determined, or how this tool relates to the similarly named sibling tools, so an agent may struggle to interpret the result or choose the right tool.

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

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

Schema description coverage is 100%, so the nine parameters are already documented in the schema. The description adds no additional parameter-level meaning, matching the baseline for full schema coverage.

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,' and adds a meaningful method qualifier, 'No browser is launched.' It does not explicitly differentiate from sibling tools such as browser-url-ok, but the no-browser caveat hints at the distinction.

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

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

The only usage signal is 'No browser is launched,' which implies this is for lightweight URL openability checks when browser automation is not needed. It does not name alternatives or state when not to use it, leaving the guidance implicit.

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

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

No annotations are present, so the description carries the behavioral disclosure burden. It does disclose that the query is discarded, which signals no persistence and a read-only operation. However, it does not state the return value, behavior with empty input, or how multiple supplied parameters are handled, leaving the behavior only partially transparent.

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

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

The description is two short sentences with the purpose front-loaded and no filler. The discard note is a useful behavioral addition. It is appropriately sized for a simple utility tool.

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

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

For a tool with nine optional parameters and no output schema, this description is too sparse. It does not explain what the tool returns, which parameter is the search query, or whether the extras are acceptable, relevant, or should be omitted. An agent could call it with the wrong parameter or miss that it returns a length value.

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 every parameter individually. The description adds no new parameter semantics beyond referencing 'search query' and 'query discarded,' and it does not clarify why eight unrelated optional parameters exist or whether only the 'query' parameter should be passed.

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

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

The description states a concrete operation: count characters in a search query. This is reasonably distinct from sibling URL, weather, fetch, and validation tools. It could be clearer that the relevant input is the 'query' parameter among the nine optional parameters, but the verb and resource are specific.

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. Sibling tools are not mentioned, and no selection conditions or exclusions are provided. An agent must infer that this tool is for search-query length checks rather than, for example, counting tokens or counting memory keys.

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 discloses nothing about side effects, read-only behavior, return format, or how inputs affect the catalog. The word 'catalog' weakly implies a read operation, but that is not explicit and no behavioral traits are actually revealed.

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

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

The description is a single short fragment with no filler or redundant clauses. It is front-loaded with the core subject. However, it is under-specified enough that brevity comes at the cost of clarity, so it does not earn a 5.

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

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

The tool has nine parameters, no annotations, no output schema, and many siblings, yet the description is only seven words. The parameter descriptions in the schema fill some gaps, but the overall purpose, expected behavior, and relationship between inputs and the catalog remain unexplained. This is far from complete.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters. The description adds no parameter-level meaning and does not explain how parameters like city, zone, or json relate to a status-code catalog. Baseline 3 applies because the schema carries the parameter semantics.

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 essentially a noun phrase: 'Short catalog of common HTTP status codes.' It identifies the resource but never states what the tool does with it or what action it performs. It also does not distinguish the tool from siblings like fetch-status or browser-url-ok, which could also relate to HTTP statuses.

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 any of the 27 siblings. The description implies a reference lookup use case, but it never states conditions, exclusions, or alternatives. An agent must guess whether to use this instead of fetch-status or agent-tool-index.

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 explicitly discloses that the prompt is discarded and that a fixed template is returned, which is a key behavioral trait beyond any annotations. This transparency helps the agent avoid expecting prompt-dependent behavior, though it does not describe the template's content.

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 zero waste. The primary purpose is front-loaded, and the behavioral caveat follows immediately.

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

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

For a tool that returns a static template and ignores inputs, the description is sufficient. It does not explain the template's steps, but the name 'think-steps' and the phrase 'three-step thinking template' provide enough context for an agent to understand the tool's role.

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

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

The schema already documents each parameter as discarded after a shape check, so the description adds little new parameter meaning. The statement 'Prompt discarded' reinforces the schema but does not expand on parameter usage.

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

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

The description clearly states the tool returns a three-step thinking template, which is a specific output. The phrase 'Prompt discarded' clarifies that it does not process the prompt, distinguishing it from sibling tools that perform checks or transformations.

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

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

No guidance is given on when to use this tool versus alternatives. It does not mention scenarios or prerequisites, leaving the agent to infer that it is a simple template-returning utility.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does state the primary behavior—returning the current time—but does not describe what happens with invalid timezone names, whether the result includes the timezone name, or that unrelated schema fields are discarded. The parameter descriptions partially cover the discards, but the tool description itself adds little beyond the core 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 a single, front-loaded sentence with no filler. Every word contributes to meaning. It is an appropriately sized description for a simple tool.

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

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

The input schema contains nine parameters, many seemingly unrelated to timezone lookups, and the description does not explicitly warn that only zone is relevant. There is no output schema or annotation to fill in details like return format or error behavior. While the parameter-level descriptions help, the overall description is sparse for the complexity of the schema.

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 a semantic tie between the IANA timezone mention and the zone parameter, but it does not provide additional parameter meaning beyond what the schema already states. The schema already describes zone as an 'IANA timezone name,' so the description adds no new parameter-level detail.

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, 'Current time in a named IANA timezone,' states a specific action and resource: it returns the current time for a user-specified IANA timezone. This clearly distinguishes the tool from siblings like utc-time (current UTC time) and iana-zones (list of available zones). The verb and scope are immediately obvious.

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

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

The description implies when to use the tool: when a current time for a named IANA timezone is needed. However, it does not explicitly mention alternatives or exclusions, such as using utc-time for UTC or iana-zones for listing zone names. Usage context is clear but left to inference rather than spelled out.

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 reveals the basic behavior (returns timestamp) but fails to explain the purpose of the nine seemingly irrelevant parameters (e.g., 'city', 'feed', 'json'). Without annotations, the description carries the burden, and it leaves the tool's behavior opaque regarding parameter effects and side effects.

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

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

The description is a single concise sentence, perfectly sized for the minimal information it conveys. No redundancy or unnecessary detail.

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 severely incomplete: the description does not explain why it accepts parameters like 'url', 'host', or 'path', or how they relate to obtaining a UTC timestamp. The presence of these parameters without explanation creates significant gaps in understanding the tool's actual functionality.

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 descriptions are nonsensical for a UTC-time tool (e.g., 'Git ref name; discarded after the shape check', 'City name for a public weather hint'). These descriptions do not add meaning and actively confuse the tool's actual 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 'Current UTC timestamp.' clearly states that the tool returns the current UTC time. It is specific enough to distinguish from generic time tools, though it does not mention output format or units.

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 like 'timezone' or 'iana-zones'. No usage context or conditions are provided.

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

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

The description adds the important disclosure that the body is discarded after validation, which is a meaningful behavioral trait beyond a plain 'validate' phrasing. The schema parameter descriptions also repeatedly emphasize 'discarded', reinforcing that inputs are not retained. It does not, however, describe the return value or error behavior, which would be needed with no annotations present.

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 action and a key side-effect (discarding) are front-loaded. It is appropriately minimal for the stated purpose, though it could have used the space to clarify the parameter mapping.

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 in the schema and no output schema, the description is insufficient: it does not explain that only the 'json' parameter is relevant (if true) nor how the other parameters (url, feed, city) should be handled. The contradictory breadth of the schema versus the narrow description leaves an agent without enough context to call the tool reliably. Return format and error cases are also absent.

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

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

The input schema already describes all seven parameters, so the schema carries the param documentation burden; baseline is 3. The description itself adds no parameter-level information and does not map the generic term 'body' to the 'json' property, which could cause an agent to use the wrong parameter. Given the high schema coverage, this is acceptable but not improved by 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 uses a specific verb ('Check whether') and resource ('a body is valid JSON'), clearly stating the core function. However, the input schema lists many unrelated parameters (url, feed, city, etc.) that are not mentioned in the description, creating ambiguity about the tool's actual scope. The description does not explicitly identify the 'json' parameter as the body.

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 contains no guidance on when to use this tool versus siblings like domain-shape, normalize-url, or wiki-title-ok. There are no exclusions, conditions, or references to alternatives. An agent must infer the appropriate context solely from the tool name.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies an external read-only API call, but does not describe side effects, rate limits, output format, or how the many discarded parameters are handled. This is a meaningful gap for an agent deciding whether and how to invoke it.

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

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

The description is a single sentence with no filler, front-loading the primary action and provider. It is concise and every word contributes to the core purpose, even though brevity causes under-specification in other dimensions.

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

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

With no output schema, no annotations, and nine optional parameters, a one-sentence description is insufficient. It omits the result format, units, and which parameters actually feed the request, making it hard for an agent to confidently interpret the tool's behavior.

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

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

Schema description coverage is 100%, so the baseline is 3; the schema already documents each property, including which ones are discarded. The description only maps to the 'city' parameter and adds no additional meaning beyond what the schema provides.

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

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

The description states a concrete operation: retrieving the current temperature for a city, and names the external provider Open-Meteo. This makes the tool's purpose clear and broadly distinguishable from generic fetch or check tools, though it does not explicitly contrast with sibling tools.

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

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

The description clearly implies the intended use case: when a user needs the current temperature for a city. It does not mention alternatives or exclusions, but the context is strong enough for an agent to know when this tool is relevant.

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

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

With no annotations, the description carries the behavioral burden, and it does disclose one useful behavior: the response body is discarded. However, it does not describe redirect handling, timeouts, error behavior, or the fact that only the url parameter appears to be the meaningful input.

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

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

Two short sentences with no filler. The first states the result, and the second states a critical limitation, so both sentences earn their 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 whose core operation is fetching a public URL, the description plus the fully documented schema is nearly sufficient. It lacks sibling differentiation and an explicit statement that only url matters, which would be needed to fully guide tool selection and invocation.

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

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

The schema has 100% description coverage, so the description is not required to re-document parameters. It reinforces that url is the relevant input, but it does not clarify that the other eight optional parameters are effectively ignored rather than being meaningful alternatives.

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

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

The description names a concrete operation: it returns HTTP status and content type for a public URL, and clearly notes that the body is discarded. This is specific and understandable, though it does not explicitly differentiate web-fetch from sibling URL-checking 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?

There is no guidance about when to prefer this tool over the many URL-related siblings, nor any mention of alternatives or when not to use it. The phrase 'public URL' implies a scope constraint, but it does not help an agent decide between web-fetch and the other similar 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?

The phrase 'Title discarded after the call' adds a small behavioral note, but no annotations exist to cover side effects, network access, return behavior, or failure modes. For a tool that checks external Wikipedia titles, much more behavioral disclosure is needed.

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

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

Two short sentences, front-loaded with the core purpose and no filler. The description is very concise and easy to parse, even though it is incomplete in other dimensions.

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 eight parameters, no annotations, no output schema, and a description that does not map input to purpose, an agent cannot safely or correctly invoke this tool. The description does not explain what the result looks like, what the parameters mean for this tool, or what errors may occur.

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 never connects the 'Wikipedia title' to any of the eight input schema properties. None of the schema parameters is named 'title' or described as a Wikipedia title, so an agent cannot determine how to pass the required input. The schema descriptions cover their own fields but do not support the tool's stated purpose.

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

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

The description states a specific verb and resource: 'Check whether a Wikipedia title exists.' This clearly distinguishes it from sibling tools like domain-shape, validate-json, or normalize-url, all of which target different objects.

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 exclusion criteria, and no mention of related tools. The purpose is clear, but the description leaves the selection decision entirely to the agent.

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