Currency TRY

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

The description discloses two behavioral traits: task text is discarded (privacy note) and the call returns specific artifacts. This adds some transparency beyond the bare 'find' action. However, there are no annotations to fill gaps around side effects, authentication, or rate limits, and the description does not address those either.

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

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

The description is two sentences and 21 words, with the action verb-led and front-loaded. Each clause earns its place: what the tool does, what it returns, and a privacy-relevant note. No filler or 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?

For a tool with 14 optional parameters and no output schema, the description does not clarify whether arguments are needed at all, which parameter is the primary input, or how the returned artifacts are delivered (inline text, file paths, etc.). The purpose is clear, but an agent could not invoke it confidently without guessing about parameter relevance.

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 description coverage for all 14 optional parameters, including several that state 'discarded after the call.' The tool description only repeats that task text is discarded and does not explain which parameters drive the lookup or whether any are required. It adds no meaning beyond the schema, so the baseline of 3 applies.

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

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

The description names a specific resource (Monid) and a clear action (find), and lists the returned artifacts (CLI setup, how-it-works, skill file, remote MCP hops). This distinguishes it from all sibling tools, none of which mention Monid or a pay-per-call gateway. It lacks an explicit sibling comparison, so it stops short of a 5.

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

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

The usage context is implied: use this tool when you need information about the Monid gateway. However, it does not state when to prefer this over alternatives like web-fetch or normalize-url, nor does it provide exclusions or prerequisites. This is implied usage rather than explicit guidance.

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

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

With no annotations, the description carries the full burden. It does disclose a meaningful behavioral trait—no browser is launched—and 'check' implies a read-only operation. However, it does not clarify whether the tool makes a network request or merely validates URL shape, and 'can be opened' remains ambiguous.

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

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

Two short sentences with no wasted words. The core purpose is front-loaded and the key behavioral caveat follows immediately. Every part earns its place.

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

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

The tool has nine optional parameters, no output schema, and no annotations, yet the description does not explain what the tool returns, how 'opened' is determined, or that only `url` should be used. An agent has too little context to invoke it confidently.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the free-text description adds nothing about parameters. The schema's `url` description, 'HTTPS URL to normalize or cite,' does not fully match the tool's stated purpose, and most other parameters appear irrelevant or discarded. The property name `url` helps, but the description does not disambiguate which parameter actually matters.

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 whether a URL can be opened. The second sentence, 'No browser is launched,' differentiates it from browser-based siblings like playwright-url-ok, so an agent can tell what this tool does without opening 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 implies a lightweight/headless URL check through 'No browser is launched,' but it never explicitly states when to use this tool versus alternatives such as playwright-url-ok, fetch-status, or web-fetch. Usage guidance is only implied, not 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, the description carries the full burden of behavioral disclosure. It neither explains what the tool returns, what side effects occur, nor how the many input parameters are handled beyond vague 'discarded' comments in the schema. The single clause 'Expression discarded' is cryptic and does not convey behavior.

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

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

The description is extremely short, which on its own could be good, but it is not front-loaded with useful information. The key phrase 'a+b style arithmetic' does not match the schema, and 'Expression discarded' is confusing. Being brief is not valuable if it fails to communicate.

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

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

This tool has 9 parameters, no required fields, no output schema, and no annotations. The description does not explain what the tool does with these parameters, what the output would be, or how it connects to the tool name. It is completely inadequate for an agent to invoke correctly.

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

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

Although schema coverage is 100% and each parameter has a description, the tool description adds no value per parameter. Worse, it introduces an arithmetic concept that does not map to any schema parameter, making it harder for an agent to understand how to fill in the fields.

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 clear verb and resource, but the input schema has no parameter for an expression (no 'a' or 'b'). This makes the purpose ambiguous and potentially misleading. The phrase 'Expression discarded' adds confusion rather than clarity about what the tool does.

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

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

No guidance is given on when to use this tool versus any of the 26 siblings. The description does not hint at use cases, prerequisites, or exclusions. An agent has no way to choose this tool correctly.

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 disclosure burden. It adds one useful privacy behavior ('Page content is not stored') but does not disclose whether a network request is made, whether redirects are followed, authentication needs, rate limits, or why the many other parameters are accepted and discarded.

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

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

The description is one front-loaded sentence with no wasted words: the core action and output are stated immediately. However, it is arguably too terse for a tool with nine optional parameters and many sibling tools, so it sacrifices completeness for brevity.

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

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

Given the tool has nine optional parameters, no required parameters, no output schema, no annotations, and many similar siblings, this description is not complete. It does not explain which parameter to use, what the returned status structure looks like, or when this tool is the correct choice.

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. The description itself adds no parameter-level meaning; it only mentions 'a URL' while the schema accepts city, feed, json, zone, query, and others. This mismatch weakens clarity, but the schema descriptions compensate individually.

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

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

The description clearly states the action ('Return') and the resource ('a URL'), and lists the outputs: host, scheme, and HTTP status. However, it does not differentiate this tool from siblings like fetch-status, normalize-url, or browser-url-ok, which may also return URL-related information.

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

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

The description gives no when-to-use guidance, no mention of alternatives, and no indication of which of the nine optional parameters should be supplied. An agent cannot tell when to choose this tool over fetch-status or normalize-url, nor which parameter (url vs host vs feed) is appropriate.

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 states 'No identifiers are retained' and parameter descriptions mention values are 'discarded after the shape check', which provides some transparency about data handling. However, it does not disclose whether the tool has any side effects, network access, or what it returns.

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 unnecessary words, making it concise. However, it is so sparse that some important information is missing, which slightly lowers the score from 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 9 optional parameters and no output schema, the description is not complete enough. It never explains what 'classified' means, what output to expect, or how to use the parameters together.

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 descriptions cover 100% of the parameters, each with a brief explanation of its type and purpose, so the baseline is 3. The tool description itself adds no additional relational meaning or guidance about how the parameters interact.

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 'Show how this request is classified' is vague and does not specify what 'request' refers to or what classification means. It also does not distinguish this tool from the many sibling shape/checker tools.

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

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

There is no guidance about when to use this tool versus alternatives like normalize-url, validate-json, or domain-shape. No conditions, exclusions, or preferred use cases 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 behavioral disclosure burden, and it explicitly states the key limitation: no WHOIS or ownership data is fetched or included. The described behavior is a non-destructive local split operation, so the absence of side-effect details is not a serious gap.

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

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

The description is one tightly worded sentence with the core operation front-loaded and the limitation appended concisely. There is no filler, repetition, or unnecessary elaboration.

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 gives a clear purpose, but with no output schema and many optional parameters it does not state required inputs, the return format, or how to route between domain-shape and sibling shape/url tools. The schema's parameter descriptions partly compensate, but tool-level invocation details are left to inference.

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 detail. The only indirect link is 'hostname' in the description matching the schema's 'host' parameter, but no new semantics beyond the schema are provided.

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 ('split a hostname into labels') and a clear resource, with the qualifier 'without WHOIS or ownership data' scoping it as a lexical parse rather than a lookup. This helps distinguish it from sibling URL/status/shape tools such as normalize-url, fetch-status, and figma-url-shape.

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

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

Usage context is only implied: the tool should be used when hostname labels are needed and WHOIS/ownership data is not. It does not explicitly state when to use this tool versus alternatives, nor does it name any sibling tool as a fallback, despite many closely related siblings.

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

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

No annotations are provided, so the description carries the full burden, yet it discloses behavior for only one of nine modes: HEAD (non-destructive, no body) and status-only return. The disposal semantics of the other eight inputs ('discarded after the shape check', 'titles discarded', 'no disk access') live only in the schema, and the tool's central trait — that it validates any one of several input shapes and returns a status — is never stated.

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 single sentence is terse and front-loaded, but its brevity is achieved by omitting the tool's actual surface: nine input modes condensed into 'a public URL.' This is under-specification rather than successful conciseness, since the sentence describes a different (narrower) tool than the schema defines.

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 parameters, 0 required, no annotations, and no output schema, the tool-level description needed to explain that exactly one input is expected and what 'status' means (HTTP code vs boolean vs envelope). Instead only the URL case is described, leaving the agent unable to determine correct invocation for the other eight modes; the rich schema param descriptions partially compensate, which keeps this above a 1.

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% and the per-parameter schema descriptions are genuinely informative (input purpose plus disposal behavior), so the schema does the heavy lifting and the description itself adds no parameter detail. It is not neutral, however: 'HEAD a public URL' contradicts the schema's own url semantics ('HTTPS URL to normalize or cite'), actively reducing the description's value below the coverage-100% baseline.

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

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

The description names a concrete verb and resource ('HEAD a public URL ... status only'), which is clear for a narrow URL case, but not for this tool: the schema exposes nine distinct input modes (ref, city, feed, json, path, zone, query, host, url) whose checks have nothing to do with HTTP HEAD. The description therefore materially misrepresents the tool's scope and does nothing to separate it from URL-related siblings like web-fetch, playwright-url-ok, browser-url-ok, or normalize-url.

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

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

There is zero when-to-use or when-not-to-use guidance and no mention of alternatives. Worse, the only usage the description implies — 'use this to HEAD a URL' — is contradicted by the schema, where url is described as 'HTTPS URL to normalize or cite' and where seven other parameter modes exist, so an agent would be actively misdirected rather than merely unguided.

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

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

With no annotations, the description must carry the behavioral burden. It discloses one useful trait—'Path discarded'—but it does not state what the parsed result looks like, whether only Figma HTTPS URLs are accepted, or that the other eight schema parameters are effectively irrelevant to this tool.

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

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

The description is concise and front-loaded, with no filler: it states the action in the first sentence and the key behavioral wrinkle in the second. It loses a point because 'Path discarded' is elliptical and could mislead an 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?

The tool has nine optional parameters, no annotations, and no output schema, but the description never tells the agent which parameter to supply, what the parsed output is, or how a non-Figma URL should be handled. The definition leaves too much to inference for reliable invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds only the ambiguous phrase 'Path discarded,' which could refer either to the URL path or to the 'path' parameter, so it does not meaningfully improve on the schema's own parameter descriptions.

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

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

The description names a specific verb and resource: parse a Figma file URL, and adds the behavioral note that the path is discarded. It is clear about the core intent, but it does not explicitly differentiate this tool from sibling URL/shape tools such as normalize-url or domain-shape.

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

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

No guidance is given about when to use this tool versus alternatives. The sibling list contains several similar URL-parsing or URL-checking tools, yet the description offers no selection criteria, exclusions, or context about which URL shapes belong here.

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

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

With no annotations, the description carries the full behavioral burden. 'No disk access' usefully signals a side-effect-free shape check, but the description does not disclose the return format, what exactly counts as 'safe,' 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 two short sentences with no filler, and the most important detail ('No disk access') is front-loaded. It is concise and easy to scan, even though it is content-sparse overall.

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 description is too thin to support correct invocation. An agent cannot tell whether exactly one parameter is expected, what the tool returns, or why parameters like host and json appear in a tool named file-path-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?

All nine parameters have schema descriptions, so the baseline is 3; the tool description adds no real parameter meaning beyond restating the path concept. The mismatch between the path-focused description and unrelated parameters (url, city, feed, zone, query) is unresolved, which weakens agent confidence about which parameter to provide.

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 ('check whether a path looks safe') and adds the key boundary 'No disk access,' which separates it from tools that inspect real files or URLs. However, 'safe' is somewhat vague, and the broad input schema with params like url, city, json, and host undercuts the apparent path-only scope.

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

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

There is no when-to-use or when-not-to-use guidance, and no mention of sibling alternatives such as browser-url-ok or normalize-url. The 'No disk access' line hints at safe usage but does not tell an agent when to choose this over the many related 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 full burden of disclosing behavior, but it only states the output and data source. It does not mention external network calls, which parameter is expected, that most other parameters are 'discarded', or any side effects. The schema hints at broader behavior, but the description itself is too 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. While it is concise, it is arguably too terse for the complexity of the 9-parameter schema, so it does not earn 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?

Given the high complexity (9 optional parameters, no output schema, no annotations), the description is incomplete. It covers one narrow use case but does not explain return format, which parameters to provide for which outcome, or why unrelated parameters like 'json' and 'path' exist.

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 context about the 'place' concept and the Open-Meteo provider, but it does not meaningfully explain the relationship between the 9 parameters and 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 clear, specific purpose: returning latitude and longitude for a place via Open-Meteo. It names a resource ('place') and a provider, making the core function understandable, though it does not differentiate from sibling tools like weather-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?

The description implies when to use it: when a latitude/longitude for a place is needed. However, it provides no explicit guidance about alternative tools, exclusions, or the fact that the schema accepts many unrelated parameters.

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

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

There are no annotations, so the description alone must disclose behavior. It only states the parsing action and says nothing about invalid URL handling, return behavior, or that the many optional parameters are discarded after the check. This leaves an agent guessing at edge cases.

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 works toward the primary 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?

The core purpose and input are clear, and the schema explains the optional/discarded parameters. However there is no output schema or annotation, so the return format and invalid-input behavior are not specified, leaving a gap for a fully complete description.

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 input schema already documents all parameters. The description adds no new parameter-level meaning beyond identifying url as the source of the owner/repo, so the baseline of 3 applies.

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

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

The description "Parse owner and repo from a GitHub URL" uses a specific verb and resource, naming both the input kind and the expected extraction. It distinguishes this tool from sibling *-shape and *-ok tools that handle other domains.

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

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

The phrase "from a GitHub URL" gives a clear trigger: use this when an agent needs the owner and repo from a GitHub link. It doesn't explicitly name alternatives or exclusions, but the context is specific enough to route the call.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does disclose one useful trait: 'Titles discarded.' However, it does not mention that all 9 input parameters appear to be ignored, whether any network access is involved, whether the operation is read-only, or what the return value looks like. This is adequate for a simple counter but leaves notable gaps.

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 purpose is front-loaded, and the second sentence adds a relevant behavioral note. This is appropriately concise for the tool's apparent simplicity.

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 state what the function returns (e.g., an integer count). More importantly, the input schema exposes 9 unrelated optional parameters, and the description never explains that these are irrelevant or ignored. An agent could reasonably be confused about whether it must pass a URL, feed, or query. The description is incomplete for safe, correct invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level guidance, but the schema already documents each parameter and marks them as discarded or checked. Still, the description does not clarify that the tool likely needs no arguments, which would have been valuable given 9 optional and seemingly irrelevant parameters.

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

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

The description states a specific verb and resource: 'Count current Hacker News front-page stories.' This is unambiguous and clearly distinguishes the tool from all listed siblings, none of which target Hacker News front-page counting. The added 'Titles discarded' further clarifies scope.

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

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

The description gives a clear context for use: when the agent needs the count of current Hacker News front-page stories. It does not explicitly name alternatives or exclusions, but the use case is specific enough that an agent can infer when to choose it over generic fetch or URL 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 at all, the description carries the full burden of disclosing behavior, but it says nothing about side effects, return format, or what the tool does with its nine supplied parameters. The parameters themselves look unrelated to timezone names, yet no part of the description accounts for them.

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

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

The description is a single short sentence with no filler and no wasted words. The core resource is front-loaded; the sentence accomplishes exactly the minimum expository job that it attempts.

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 a single eight-word phrase is not enough context for an agent to invoke it correctly. The rich per-parameter schema descriptions help at the field level, but they do not cover the return value, the actual behavior, or how the parameters are to be composed.

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

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

Schema description coverage is 100%, so the baseline of 3 applies even though the tool description itself adds no parameter-level guidance. The description never explains how params like ref, url, or query relate to IANA zones, and while the schema describes each parameter, it doesn't clarify which ones are relevant.

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

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

The phrase 'Common IANA timezone names for clock calls' identifies the resource and a domain, but it has no verb and does not state what the tool actually does with these names. It does little to differentiate from sibling tools like timezone or utc-time, leaving the agent to guess whether it returns, validates, or lists them.

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?

'For clock calls' hints at an intended context, which gives an implied usage cue. The description doesn't say when to prefer iana-zones over alternatives or when not to use it, so the guidance remains weak and relies on 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?

No annotations are provided, so the description carries the full disclosure burden. It indicates a read-only fetch and a limited return value, but says nothing about network failures, missing robots.txt, redirects, rate limits, authentication, or side effects.

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

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

The description is a single front-loaded sentence with no wasted words, stating the action and output scope. It is appropriately concise as prose, though it is very terse for a 9-parameter tool.

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

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

With 9 optional parameters, no annotations, and no output schema, a one-sentence description is not enough. It fails to identify which inputs are needed, what 'group counts' means, or how edge cases are handled, so an agent cannot reliably invoke the tool.

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

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

Although schema coverage is 100%, the parameter descriptions are largely unrelated to robots.txt (city, feed, json, zone, query, etc.) and the description never maps any parameter to the robots.txt URL or host. High schema coverage is undermined by the mismatch between the tool purpose and the actual parameters.

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

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

The description names a concrete verb ('Fetch'), a specific resource ('a public robots.txt'), and an explicit output ('return group counts only'), so an agent can tell what the tool does. It does not explicitly distinguish itself from sibling fetch/URL tools, so it stops short of a 5.

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

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

There is no guidance on when to use inspect-robots instead of web-fetch, fetch-status, domain-shape, or other siblings, and no exclusions or prerequisites are given. The phrasing only implies a robots.txt use case without providing any routing context.

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

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

With no annotations, the description must carry the full behavioral burden. It does disclose that the key is discarded and that file path checking involves no disk access, but it never says what the tool returns, whether it validates by pattern or lookup, or what side effects (if any) occur beyond discarding 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 the primary action front-loaded and no filler. The 'Key discarded' note earns its place as a behavioral disclosure rather than being buried in 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?

Despite the high schema coverage, the tool is highly incomplete in context: no output schema, no annotation, nine optional parameters, and no explanation of how the key is captured or what 'shape check' yields. An agent cannot reliably determine required input or expected output from 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, and each parameter has its own schema-level description. However, the description itself adds no guidance linking these nine parameters to the 'Jira key shape' purpose, leaving the agent to guess which parameter is the actual key.

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 and action: 'Check a Jira issue key shape.' This hints at a validation tool similar to sibling shape checkers. However, clarity is undermined because the input schema has no 'key' parameter and its nine parameters appear unrelated to Jira keys.

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

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

No guidance is given about when to use this tool versus siblings like github-repo-shape, domain-shape, or validate-json. The description implies usage through its purpose sentence but offers no exclusions, prerequisites, or alternative routing.

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 two useful behaviors: the output is an HTTP status and the body is discarded. Since no annotations are present, this partially covers the safety and return-behavior burden, but it leaves out error handling, network side effects, rate limits, and what happens for non-library or malformed URLs.

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

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

The description is two short sentences with no filler. The core behavior is front-loaded and the body-discarded detail is relevant and efficiently stated.

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 simple surface description, the tool has 9 optional parameters, no annotations, and no output schema. The description gives no indication of which parameter(s) matter, whether unrelated parameters are ignored, or what the exact status return format is, leaving an agent with insufficient context to reliably invoke the tool.

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

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

Schema description coverage is 100%, so the schema already documents every parameter. The description adds no parameter-level meaning and its 'public library docs URL' phrasing does not cleanly map to the url parameter's schema description ('HTTPS URL to normalize or cite'), but it also does not need to compensate because the schema is fully covered.

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 reports an HTTP status for a public library docs URL and that the body is discarded, so an agent can infer the core operation. However, it does not explicitly name or distinguish sibling tools like fetch-status or web-fetch, and it lacks an explicit verb such as 'returns' or 'fetches'.

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

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

The phrase 'for a public library docs URL' implies the tool is intended for a specific URL category, but there is no explicit guidance on when to use this tool instead of alternatives such as fetch-status, browser-url-ok, or web-fetch. No exclusions or alternative-selection rules 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 phrase 'Values discarded' is a useful behavioral disclosure beyond the basic operation. With no annotations provided, the description carries the full burden, but it does not describe error behavior, return shape, or whether nested objects are traversed, 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?

Two short, front-loaded sentences with no filler. Both sentences earn their place: one states the operation, the other states the key behavioral constraint.

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 being a simple-sounding tool, the input schema is noisy with nine optional string parameters and no output schema. The description does not explain which parameter carries the JSON object, whether the JSON should be passed as a string, or what the count result looks like, leaving an agent likely to misinvoke the tool.

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

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

Schema description coverage is 100%, which normally earns a baseline 3, but none of the nine string parameters is clearly identified as the JSON object whose keys are counted. The 'json' parameter says 'JSON text to validate', not 'JSON object to count', so the description adds no help in mapping the tool's purpose to its actual inputs.

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

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

The description states a clear verb and resource: count keys in a JSON object, with values discarded. This semantically distinguishes it from sibling tools like validate-json. However, it leaves ambiguity about whether 'keys' means top-level or nested keys, and which schema parameter actually supplies the JSON object.

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 prefer this tool over alternatives such as validate-json or search-query-len. The description neither states a clear use case nor warns against using it when values or validation are 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 behavioral burden. It usefully discloses that query and fragment are dropped, but it does not mention other normalization details, edge-case handling, or explicitly state that no network request is made.

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

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

Two short sentences with no filler. The primary output is stated first, and the key drop behavior is front-loaded in the second 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?

Despite having a nine-property schema and no output schema, the description only addresses URL normalization. It does not specify which parameters are operative, how the return value is structured, or whether URL is effectively required, leaving the tool under-specified in 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. The description adds no additional parameter-level meaning and does not clarify which of the nine schema properties are actually relevant beyond the URL.

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 (return origin, host, and path) on a specific resource (a URL), and the query/fragment dropping rule distinguishes it from sibling URL validation and fetching tools. It is immediately clear what the tool produces.

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

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

The description implies the tool should be used when URL components such as origin, host, and path are needed, but it does not explicitly name alternatives or say when not to use it. No routing among the many sibling URL-related tools is provided.

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

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

With no annotations, the description carries the full burden. It discloses that no browser is launched, which is valuable, but it omits other key behavioral traits such as whether any network access occurs, possible timeouts or errors, or side effects. The schema param comments (e.g., 'no disk access') hint at safety, but the description itself is minimal.

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 state the purpose and a critical behavioral clarification. Every word earns its place, and the key information 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?

The tool has 9 heterogeneous parameters and no output schema or annotations. The description does not explain how the parameters relate to the URL check or what the return value indicates. An agent would need to infer behavior from the name and sibling set, which is insufficient for this level of complexity.

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 9 parameters already have meaning in the structured data. The description itself adds no parameter-specific semantics beyond the schema, so a baseline 3 is appropriate.

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

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

The description gives a specific verb and resource: 'Check whether a URL can be opened.' The phrase 'No browser is launched' partially distinguishes it from browser-based sibling tools, but it does not explicitly name any sibling or define the boundary precisely, so it is clear but not fully differentiated.

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 browser-url-ok, normalize-url, or fetch-status. No when-not-to-use instructions or exclusions are given. The only behavioral note, 'No browser is launched,' implies a lightweight check but does not state which kind of check to choose it for.

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

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

No annotations exist, so the description carries the full burden. It discloses that the query is 'discarded,' which is useful, but it does not explain the return value, whether other schema fields are ignored, or any side effects. The 8 extra parameters in the schema further obscure actual 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 very short and front-loaded: the core purpose appears in the first sentence, and the second sentence adds a useful behavioral note about discarding the query. No words are wasted, though more content is needed elsewhere.

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

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

Given 9 optional parameters, no annotations, and no output schema, this definition is incomplete. It does not state which parameter is the search query, what the tool returns, or how extra parameters are treated. An agent would likely need external knowledge to call this tool reliably.

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 structured schema already documents each parameter. The description adds only the character-count intent and does not clarify how the 9 optional fields relate to the tool's purpose, but it does not need to compensate for missing schema descriptions.

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

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

The description states a clear verb and resource: 'Count characters in a search query.' This makes the core intent unambiguous and distinct from counting-oriented siblings like memory-key-count or hn-front-count. However, the input schema lists 8 additional unrelated optional parameters, which muddies the apparent scope slightly.

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

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

No guidance is given about when to use this tool versus alternatives, and no mention is made of which parameter(s) should be provided. The schema marks no parameters as required, so an agent cannot tell whether to pass only 'query' or whether the other fields are relevant. This is effectively no usage guidance.

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

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

There are no annotations to cover side effects or read-only behavior, so the description carries the full behavioral burden. 'Short catalog' vaguely suggests a read-only lookup but does not disclose what happens to the many accepted parameters or what the response contains.

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 filler, which is good for conciseness. But 'Short catalog...' is more of a label than a structured explanation, and the meager content forces the agent to rely on the schema and name for 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 seven unrelated input parameters, no output schema, no annotations, and a one-line noun-phrase description, an agent cannot tell what input to provide or what a successful call returns. The description is minimally adequate for identifying the topic but not complete enough 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?

Input schema descriptions cover all seven parameters, so the schema already explains each parameter individually. However, the description does not connect these heterogeneous parameters (ref, url, city, feed, host, json, path) to the stated purpose of cataloging HTTP status codes, leaving their role unclear.

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 the domain ('HTTP status codes') and implies an informational catalog, but it lacks a verb such as 'returns' or 'lists', so it does not clearly state what operation the tool performs. It also does not differentiate 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 on when to use status-catalog versus related tools such as fetch-status or web-fetch. The description provides no context, conditions, or exclusions that would help an agent choose this tool.

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

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

With no annotations, the description must carry the behavioral burden, but it only says 'Prompt discarded.' It fails to disclose that all seven input values are ignored after shape checks (only the schema hints at this), and it leaves the output/state-change behavior unspecified.

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

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

The text is short, but it is under-specified rather than concise; the second sentence is a fragment that creates ambiguity. It could have earned a higher score if the few words were organized around what the tool returns and why the parameters exist.

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

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

This is a seven-parameter tool with no annotations, no output schema, and an unexplained name. The description provides almost none of the context needed to call it correctly—neither the return shape, the role of each parameter, nor why 'Prompt discarded' matters. It is completely inadequate for the tool's actual complexity.

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 describes every parameter (100% coverage), so the baseline is 3. The description itself adds no parameter meaning beyond 'discarded', and the odd inclusion of seven unrelated fields is left unexplained.

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

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

The description names a concrete action ('Return a three-step thinking template') but does not define what that template contains or what 'Prompt discarded' means (there is no 'prompt' parameter in the schema). It does not clearly differentiate itself from the many sibling validation 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?

No when-to-use context is provided; the description never mentions alternatives, prerequisites, or situations where this tool should be preferred. Given sibling tools like validate-json and geo-hint, an agent gets no routing signal.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It communicates that this is a read-only time lookup, but it does not disclose behavior for invalid timezone names, the returned time format, or whether network access is involved.

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

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

The description is a single concise sentence with no filler or redundant phrasing. The key fact is front-loaded, making it easy for an agent to scan and understand the tool's purpose quickly.

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

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

Given 9 parameters, no output schema, and related sibling tools, a one-sentence description is insufficient. It does not specify how to supply the timezone, what the response contains, or how to choose this over utc-time or iana-zones, leaving too much to be inferred.

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 for all 9 parameters, so the schema already explains the parameters. The description adds the high-level concept of a named IANA timezone but does not add format constraints, examples, or clarification of which parameter holds the timezone name.

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 the current time for a named IANA timezone. It is specific enough to separate this tool from generic 'time' or 'timezone-list' utilities, though it does not explicitly use a verb like 'returns' or 'gets'.

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

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

The intended use is implied: use it when you need the current time in a specific named IANA timezone. However, it gives no explicit guidance about when not to use it or how it compares to related siblings such as utc-time or iana-zones.

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 disclosure burden. It only says 'Current UTC timestamp' and does not mention output format, side effects, or the fact that all provided parameters are discarded/ignored, which is important given the unusual input 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 a single concise sentence with no filler or repetition. It is front-loaded and easy to parse, though its brevity leaves out behavioral and usage details that would make it fully effective.

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, yet the description only provides a bare phrase. It does not explain what the returned timestamp looks like, why the parameters exist, or whether they should be supplied at all, so the description is not complete enough for confident invocation.

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

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

Schema description coverage is 100%, and each parameter already has a description, including notes like 'discarded after the call'. The tool description adds no parameter-level meaning, but the schema already handles parameter documentation, so the baseline of 3 is appropriate.

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

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

The description states the tool returns the current UTC timestamp, which is a clear, specific outcome. It distinguishes the tool from siblings like 'timezone' and 'iana-zones' by naming UTC time specifically, 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 sibling tools such as 'timezone' or 'iana-zones'. It also does not clarify that all nine input parameters are optional and effectively irrelevant, leaving the agent to infer calling conventions from the schema.

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

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

With no annotations present, the description carries the full burden. It does disclose that the body is discarded, which informs the agent about data retention. However, it does not describe what happens with invalid JSON, whether errors are returned, or how the result is communicated. This leaves significant behavioral ambiguity.

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 appropriately brief: two short sentences with no wasted words. The core purpose is front-loaded, and the discarding behavior is a meaningful additional detail. It is concise without being tautological.

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 a complex schema with many optional fields that the description does not address, and there is no output schema to clarify return behavior. The description hints at validation but does not explain how the 'body' relates to the 'json' parameter or what the caller should expect. This is incomplete for a tool with such ambiguity.

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

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

The input schema already provides descriptions for every parameter (coverage is high), so the baseline is 3. The description adds no additional per-parameter meaning and does not clarify why many seemingly unrelated properties (ref, url, city, feed, host, path) appear in the schema. It adds minimal value beyond the schema.

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

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

The description clearly states the tool's primary action: 'Check whether a body is valid JSON.' This is a specific verb+resource pairing that is easily distinguished by name. However, it does not explicitly differentiate from sibling shape-checking tools, though the JSON validation focus is 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?

No guidance is given about when to use this tool versus alternatives. The description neither mentions when it is appropriate nor names any alternatives. The 'body is discarded' note implies a side-effect-free check, but there is no explicit context for choosing this tool over similar 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?

No annotations exist, so the description carries the full burden, and it discloses only the data source (Open-Meteo) and output (temperature). It hides the dominant behavior revealed by the schema: most inputs are silently discarded after shape checks, a surprising side effect an agent should be warned about. Units, response shape, and freshness behavior are also 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 single sentence is front-loaded and has no wasted words. But it is under-specified for a 9-parameter tool: brevity is achieved by omitting explanation of the non-weather parameters and the usage context the tool clearly needs.

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

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

For a tool with 9 optional parameters, no annotations, and no output schema, the description is far from complete. It accounts for only the 'city' path and leaves agents to puzzle out why url, feed, json, path, host, ref, zone, and query are accepted, and what 'hint' semantics imply about reliability.

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 per-parameter discard semantics already documented, so the baseline is 3. The description adds nothing about parameters — it doesn't even name the 'city' field explicitly — but the schema carries the semantic load. The mismatch between the weather-only description and the 8 non-weather parameters is confusing, though it is a purpose issue rather than a parameter-documentation 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 verb+resource ('Current temperature for a city via Open-Meteo'), which is clear on its face. However, it misrepresents the tool: 8 of 9 schema parameters (ref, url, feed, json, path, host, zone, query) are non-weather inputs explicitly marked 'discarded after' checks, indicating this is a generic hint/shape-check utility rather than a weather-only tool. It also does nothing to differentiate it from sibling hint tools like geo-hint or lib-docs-hint.

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

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

There is zero guidance on when to use this tool versus the many siblings, several of which (geo-hint, lib-docs-hint, hn-front-count) occupy adjacent hint/generic-check territory. An agent gets no conditions, exclusions, or references to alternatives.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It does disclose a meaningful trait by saying 'Body discarded,' which conveys that the response content is not retained. However, it does not mention network behavior, redirects, error cases, rate limits, or why the many 'discarded' schema parameters exist.

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, front-loaded, and contains no filler. Both sentences earn their place: one states the output, the other states the body handling behavior.

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

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

For a tool with 9 optional parameters, no annotations, many sibling tools, and no output schema, this is insufficient. The agent cannot tell which parameter is the actual fetch target, how to choose between the multiple URL-related siblings, what happens when multiple parameters are passed, or what the return shape looks like. The description is a good one-liner but not a complete operational 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 even without parameter details in the description. The description adds no parameter-level meaning and does not clarify which of the 9 optional parameters is the URL whose status is being fetched, but the schema already documents each field individually.

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 HTTP status and content type for a public URL, and adds that the body is discarded. This is a specific enough purpose, but it does not differentiate web-fetch from closely related siblings like fetch-status, browser-url-ok, or playwright-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 phrase 'for a public URL' provides a scope hint and the output described implies when the tool would be useful, but the description never names alternatives, exclusions, or conditions for preferring web-fetch over sibling URL-checking tools. Usage context is only 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?

With no annotations, the description carries the full burden. It discloses that the title is discarded, but does not explain return values, side effects, or any operational behavior beyond the existence check. A simple 'check' is ambiguous regarding output format or error handling.

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 and front-load the purpose. However, the extreme brevity omits essential usage information, crossing from conciseness into under-specification.

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

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

With no output schema, no annotations, and a schema that does not match the description, an agent has no way to correctly invoke the tool. The description fails to explain which input carries the title or what response to expect.

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

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

The description refers to a 'title' but the schema contains no such parameter; instead there are unrelated parameters like ref, url, city, feed, host, json, and path. Schema descriptions cover all parameters, but they are irrelevant to the stated purpose, leaving the agent with no way to provide 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 action ('Check') on a specific resource ('whether a Wikipedia title exists'), which is a meaningful and non-tautological statement. However, it does not differentiate from sibling tools like validate-json or browser-url-ok, and the title resource is not reflected in 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?

No guidance is given for when to use this tool versus alternatives. The description only states the function purpose, with no conditions, prerequisites, or explicit exclusions.

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