ISO country KG

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

With no annotations, the description carries the behavioral disclosure burden. It does disclose that task text is discarded, and the schema reinforces that inputs are discarded or not accessed. However, it does not clarify read-only nature, network or cost implications, or authentication needs; 'pay-per-call' hints at cost but is not elaborated.

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

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

Three short sentences, front-loaded with purpose, followed by outputs and a behavioral warning. Every sentence adds distinct information and there is no redundant wording.

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 output schema and no annotations, the description is somewhat sparse. It lists return contents and a key privacy behavior, but leaves 'Monid' undefined, does not explain the role of the optional parameters, and gives no selection guidance among many 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?

Schema description coverage is 100%, so each of the 9 optional string parameters is individually documented. The description adds a general 'Task text discarded' note that helps interpret the discard semantics, but it does not explain whether or how these parameters should be supplied for the gateway lookup.

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

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

The description states a specific verb ('Find'), a specific resource ('public pay-per-call tool gateway (Monid)'), and enumerates returned artifacts: CLI setup, how-it-works, skill file, and remote MCP hops. It is distinguishable from sibling utilities by the named gateway and output list, though 'Monid' itself 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?

The use case is implied: call this tool when you need to locate the Monid gateway or obtain its setup/how-it-works/skill file/remote MCP hops. However, it gives no explicit when-not-to-use guidance and does not name alternatives among the 26 sibling tools.

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

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

With no annotations present, the description must supply behavioral context. It does disclose one key behavior: 'No browser is launched.' However, it does not explain what 'can be opened' means in practice—whether it performs a network request, checks syntax, validates HTTP status, or something else—leaving important 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 description is very concise and front-loaded: the core purpose appears in the first sentence, and the key clarification appears in the second. It wastes no words, though the brevity leaves some needed context unaddressed.

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 seven parameters, no annotations, no output schema, and several closely related siblings. A one-line purpose plus a caveat is not enough to guide an agent on which parameters to supply, what the check actually validates, what result to expect, or when to prefer this tool over nearby alternatives.

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

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

The input schema provides descriptions for all seven parameters, so schema coverage is high and the description need not repeat them. The description adds no meaning about which parameters to use for the URL openability check, and the schema itself contains several odd params like ref, city, and feed that seem unrelated to the stated purpose.

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

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

The description states a specific verb and resource: 'Check whether a URL can be opened.' It also adds the clarifier 'No browser is launched,' which helps distinguish it from a browser-based check. However, it does not explicitly name sibling tools like playwright-url-ok or web-fetch to draw 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 phrase 'No browser is launched' implies this is for quick, non-browser URL checks, giving some usage context. But the description does not explicitly state when to use this tool versus alternatives such as playwright-url-ok, fetch-status, or web-fetch, nor does it mention any exclusions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Expression discarded,' which reveals that input is not retained, but it does not explain whether the tool returns a result, executes code, reads files, performs network calls, or has side effects. This is especially important for a tool named 'calc-eval.'

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

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

The description is very short and front-loaded, with the core action in the first sentence. There is no filler or redundant information, though the second sentence is cryptic rather than merely concise.

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

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

This tool has nine heterogeneous optional parameters, no annotations, and no output schema. The description neither explains how any of those parameters relates to evaluating arithmetic nor states what happens on success or failure. An agent cannot reasonably determine how to invoke this tool correctly from the available information.

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

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

Schema description coverage is 100%, so the baseline of 3 applies; each parameter already has its own meaning in the schema. However, the tool description adds no mapping between 'a+b style arithmetic' and any parameter, so it does not help the agent decide which field should contain the expression.

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 ('Evaluate') and a resource ('a+b style arithmetic'), so the core purpose is understandable on its own. However, the phrase 'Expression discarded' is ambiguous, and none of the nine input parameters appears to hold an arithmetic expression, making it hard to connect the stated purpose to the actual 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?

There is no guidance about when to use calc-eval versus any of its many siblings, no mention of alternatives, and no context such as 'use when validating arithmetic shape' or 'use instead of calculator tools.' The agent is given no help in choosing this tool over other options.

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 transparency burden and does add one meaningful behavioral fact: page content is not stored. It does not disclose other operational details such as redirect handling, caching, or error behavior, but the read-only character is reasonably clear.

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

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

The description is two short sentences with the primary result front-loaded and a useful privacy/behavior note in the second sentence. No words are wasted.

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 covers the core input (a URL) and the return fields (host, scheme, HTTP status) in the absence of an output schema. However, with nine parameters, none required, and no mention of the other parameters' role, the description is a bit thin for an agent to confidently invoke it in all cases.

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 coverage is 100%, so the schema already documents all nine parameters. The description adds only that the operation is 'for a URL' and does not clarify which of the optional parameters are expected or how the returned host relates to the host input, so the schema is doing the heavy lifting.

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 ('Return') and a precise result: host, scheme, and HTTP status for a URL. It is clear about what the tool does, though it does not explicitly contrast with sibling tools like fetch-status or normalize-url.

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

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

There is no guidance about when to use citation instead of related tools such as fetch-status, web-fetch, or normalize-url. The 'Page content is not stored' hint weakly implies a metadata-only use case, but no condition or alternative is 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?

The description adds a useful privacy behavior: 'No identifiers are retained,' and 'Show' implies a read-only operation. However, with no annotations present, it does not disclose whether any external calls are made, how classification is computed, or whether any other state is kept; the schema-level 'discarded' notes help but are per-parameter rather than a full behavioral picture.

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 just two short sentences with no filler, and the privacy statement earns its place. It is concise and front-loaded, though 'this request' is vague enough that the overall wording is not maximally 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?

With 9 optional parameters, no output schema, and no annotations, the description is incomplete: it does not explain what the classification result looks like, how to handle multiple parameters, or when this tool should be called. The schema covers parameter semantics but not the tool's overall 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?

Since schema coverage is 100%, every parameter already has a meaningful description, including discard behavior, so the tool description does not need to repeat parameter details. The description itself adds no guidance about which of the 9 optional parameters to supply, but the schema carries that weight adequately.

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 'Show how this request is classified,' which names a verb and an output concept, but it never defines what 'this request' refers to, what classification scheme is used, or what kind of inputs the tool accepts. It also does not differentiate compatibility from the many sibling tools such as validate-json, 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?

There is no guidance on when to use this tool versus any alternative. The phrase 'request is classified' is too vague to help an agent select it for a concrete task, and no exclusions, related tools, or preferred contexts 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 present, so the description carries the full burden. It discloses one useful behavioral fact—no WHOIS/ownership lookup—but does not state return format, error behavior, normalization, or whether invalid hostnames raise errors. For a pure parser this is incomplete transparency, though not contradictory.

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

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

One sentence, front-loaded with the action, and the exclusion clause earns its place by distinguishing the tool from WHOIS/ownership tools. No fluff or repetition of schema details.

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

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

Given no annotations, no output schema, and a nine-property schema that mostly appears irrelevant to domain splitting, the description is not complete enough for an agent to reliably invoke the tool. It does not specify which parameter(s) to pass, whether other fields are ignored, or what the response looks like. The name and one-line description leave too much 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 for this dimension is 3. The description adds a slight hint that the relevant parameter is host, but with nine optional parameters and no required field it does not resolve which values the tool consumes or what happens to the others. Thus it does not exceed the 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?

States a specific verb and resource: 'Split a hostname into labels' and adds a boundary by excluding WHOIS/ownership data. This makes the core purpose clear and separates it from lookup-style tools. However, the input schema lists eight other unrelated optional fields (city, feed, json, path, zone, query, etc.), which blurs which input the tool actually operates on.

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 and names no alternatives from the sibling list (e.g., normalize-url, browser-url-ok, github-repo-shape). 'Without WHOIS or ownership data' is only a negative boundary, not actionable direction about when to choose this tool or what to use instead. An agent must guess the decision criteria.

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

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

With no annotations, the description carries the transparency burden; it does disclose the HTTP method (HEAD) and that the response is limited to status, making the operation read-only and body-free. It is silent on redirects, timeouts, error behavior, and what happens if multiple optional parameters are supplied, 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?

A single compact sentence with no filler; the key verb, target, and output are front-loaded. It is appropriately concise for the simple URL use case, though other dimensions suffer from the terseness.

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

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

For a tool with nine optional parameters, no output schema, and no annotations, this description is not complete: it only covers the URL path, gives no output format details, and does not reconcile the remaining parameters. The schema helps individually but the overall invocation contract remains unclear.

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?

Even though schema description coverage is 100%, the description narrows the tool to a URL while nine parameters are optional and unrelated-looking. The schema's own url description ('HTTPS URL to normalize or cite') also does not match the 'HEAD ... status only' behavior, so the definition does not reliably tell an agent which parameter to set.

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

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

The description clearly names a specific operation—HEAD a public URL and return only its status—which distinguishes it from body-fetching tools. However, the input schema exposes eight other optional parameters (ref, city, feed, json, path, zone, query, host), so the one-line description describes only one mode and leaves the tool's true scope ambiguous.

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

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

'Return status only' implies this is the lightweight choice when an agent needs an HTTP status rather than a full page fetch. It does not name sibling alternatives such as browser-url-ok, playwright-url-ok, or status-catalog, nor does it explain when the non-URL parameters should be used.

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 that the path is discarded, but it does not state whether the operation is read-only, what it returns, or how malformed URLs 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?

Two short sentences with no filler; purpose is front-loaded. Slightly cryptic because 'Path discarded' is ambiguous, but it earns its place as a behavioral note.

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

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

For a tool with no annotations, no output schema, and nine parameters, the description omits expected return value, input parameter mapping, and error/edge-case behavior. It is too sparse for an agent to invoke 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 baseline is 3. The description's 'Path discarded' adds little beyond the existing path parameter description, and it does not clarify which of the nine parameters is the actual Figma URL 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 identifies a specific operation and object: 'Parse a Figma file URL.' This distinguishes it from sibling shape tools like github-repo-shape or jira-key-shape. It is slightly vague about what 'parse' returns (validation vs extraction), which keeps it from 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 usage: when a Figma file URL needs parsing. It names no alternative tools or exclusion conditions, so an agent cannot tell when to prefer this over normalize-url or browser-url-ok.

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

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

With no annotations available, the description carries the full burden and explicitly states 'No disk access,' which is a meaningful behavioral guarantee for a path-checking tool. It implies a purely syntactic check without filesystem side effects, though it stops short of describing the return value or the exact unsafe patterns detected.

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

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

The description is two short sentences with no filler. The core purpose and the key no-disk-access caveat are both front-loaded and easy to parse.

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

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

Given a 9-parameter schema, no annotations, and no output schema, this description is too thin to be fully actionable. It omits what 'safe' means, which parameter to populate, and what the tool returns, leaving gaps an agent must fill by 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?

The schema already documents all 9 optional parameters with descriptions, so the baseline is 3. However, the description adds no parameter-level guidance and fails to clarify that only 'path' is relevant while the other eight fields look unrelated to this tool's purpose, which 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 verb and resource: it checks whether a file path looks safe. 'No disk access' adds a distinguishing behavioral note. It does not define what 'safe' means or explicitly contrast it with sibling tools, but an agent can tell this is a path-validation predicate rather than a URL or title checker.

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

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

There is no guidance on when to use this tool versus alternatives such as browser-url-ok, wiki-title-ok, or normalize-url. It does not mention preconditions, when not to use it, or why the no-disk-access property might make it a cheap pre-check.

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 disclosure burden, but it only reveals that the tool uses Open-Meteo. It does not mention whether the call has side effects, rate limits, error behavior, or what data is retained or discarded; the discard information lives only in the schema, not the description.

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 and is front-loaded with the main purpose. However, it is under-specified for a tool with nine optional parameters and no annotations; brevity is good, but it omits necessary 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?

Given no annotations, no output schema, and a nine-parameter input, this one-line description is incomplete. It does not state the return format, which parameter to populate, failure behavior, or how this differs from related hint tools, so an agent cannot confidently invoke it correctly.

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

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

Input schema coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning and does not map the vague 'place' to a specific parameter such as city or query, but the schema already documents each parameter, so no lower score is warranted.

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 latitude and longitude for a place and names the external source (Open-Meteo). It distinguishes the tool from weather-hint by focusing on coordinates, though it lacks an explicit verb and does not specify which input parameter identifies the place.

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 geo-hint versus the many sibling tools, and there are no stated conditions, prerequisites, or exclusions. The single sentence only implies a use case, leaving tool selection 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?

No annotations are provided, so the description carries the full behavioral disclosure burden. 'Parse' implies a read-only string operation, but the description does not mention error behavior for non-GitHub URLs, whether the URL is fetched, or that unrelated accepted parameters are 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?

A single sentence with no filler. The verb and resource are front-loaded, making the tool's purpose immediately understandable.

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 and no output schema, yet the description only explains the core parse behavior. It does not specify which parameter is required, what the output structure is, or how invalid inputs are handled, leaving some ambiguity for autonomous 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 each parameter already has a description. The tool description adds the important link that the URL parameter is the GitHub URL to parse, but it does not clarify which of the nine parameters should be supplied or that the rest are irrelevant.

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 (parse) and resource (owner and repo from a GitHub URL). It clearly distinguishes this tool from sibling shape tools like domain-shape and figma-url-shape.

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

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

The description makes the intended use clear: use this tool when you need to extract owner and repo from a GitHub URL. It does not explicitly name alternatives or when-not-to-use conditions, but the context is strong enough for selection.

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

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

With no annotations provided, the description carries the behavioral transparency burden. It discloses that titles are discarded and that the count is of current stories, implying a read-only live fetch. It does not mention error behavior, network dependency, or how the nine optional schema parameters are treated, leaving some behavior opaque.

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

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

Two short sentences with no filler. The primary action is front-loaded, and 'Titles discarded' is a useful, non-obvious clarification stated in a single phrase.

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 zero-required-parameter counting tool, the core return behavior is stated. However, given nine optional parameters and no output schema, an agent cannot tell whether the tool accepts a feed or URL to count a different source or whether all parameters are ignored. This is the main completeness gap.

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

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

Schema description coverage is 100%, so the baseline is 3; the schema already documents each parameter. The description adds no mapping between the tool and the nine optional parameters, so an agent cannot tell from the description which, if any, parameter should actually be supplied for hn-front-count.

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

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

The description clearly states a specific operation ('Count') and a specific resource ('current Hacker News front-page stories'), and 'Titles discarded' clarifies that the result is a count rather than article content. It is distinguishable from sibling tools like web-fetch or wiki-title-ok, though it does not explicitly contrast itself with 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?

The intended use is implied: call this when the goal is to know how many stories are currently on the HN front page. However, there is no explicit when-to-use or when-not-to-use guidance, no mention of alternatives, and no indication whether a feed URL or other parameter should be supplied.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It never states an action, return shape, or constraints such as whether the tool validates names or returns a static list, and the input properties are unexplained in relation to the tool's behavior. Only a content-domain implication exists.

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 one-sentence description is short and has no filler. Yet for a tool with nine optional parameters and no annotations, this brevity is under-specification rather than effective conciseness.

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

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

With no annotations, no output schema, and a 9-parameter schema containing unrelated-looking fields (ref, url, city, feed, host, json, path), the description leaves the tool's actual behavior and relevant inputs almost entirely unstated. An agent has no way to know what a successful call 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?

All 9 properties have schema descriptions, so the baseline is 3. The prose adds nothing about how any parameter relates to IANA zone lookups, but the schema itself handles parameter documentation. It does not mislead.

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

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

The description identifies content ('Common IANA timezone names') and a purpose ('for clock calls'), so an agent can roughly infer the tool provides zone names. However it lacks an explicit verb such as 'list' or 'return', and it does not clearly distinguish this from neighboring timezone-related tools. It rises above a tautology but remains vague.

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 clock calls' hints at a use case, but there is no explicit when-to-use, when-not-to-use, or alternative routing to timezone/utc-time. An agent cannot confidently choose this over siblings based on the description alone. Only implicit context exists.

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

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

With no annotations, the description carries the behavioral burden. It does disclose the two key traits: the operation is a public HTTP fetch and the return is deliberately limited to group counts. It does not mention failure modes, rate limits, redirects, or which schema property supplies the robots.txt URL, 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?

One short sentence, no filler, and the key behavioral constraint ('group counts only') is front-loaded. Every word earns its place.

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

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

The tool has nine optional parameters and no output schema, and the description never says which parameter carries the robots.txt URL or what a 'group' means. An agent would have to inspect sibling naming or the generic parameter list to know how to call it correctly, which makes the description incomplete for a tool this loosely constrained.

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. It also does not map its own nouns ('robots.txt', 'group counts') to any of the nine schema properties, so it adds no parameter-level meaning.

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 ('Fetch a public robots.txt') and a specific output ('return group counts only'). It clearly distinguishes this tool from generic fetch tools like web-fetch and fetch-status by narrowing both the resource and the return value.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no alternative tools are named. However, 'group counts only' implies this is for agents that need summary counts rather than raw robots.txt content, so usage is at least inferable.

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

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

With no annotations provided, the description carries the full behavioral burden. It does disclose one meaningful trait—'Key discarded'—indicating the key is not stored or returned beyond the shape check. However, it does not disclose return values, failure behavior, or whether any external calls are 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?

The description is very short, with the main purpose front-loaded and no filler. The second sentence adds a useful behavioral detail, though it is terse enough to create ambiguity about what 'key discarded' means in practice.

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

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

For a tool with nine parameters, no output schema, and no annotations, this description is severely incomplete. It fails to explain the Jira key format, which parameter to use, what the tool returns, or any edge cases, 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 schema description coverage is 100%, the schema parameters (ref, url, city, feed, host, json, path, zone, query) do not include anything that clearly represents a Jira issue key, and the description never maps 'Jira issue key' to a specific parameter. The agent cannot determine which field to populate, making the tool effectively unusable from the definition alone.

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 verb and resource: 'Check a Jira issue key shape.' This differentiates it from sibling shape-validators like github-repo-shape or domain-shape. The added note 'Key discarded' further clarifies that the tool only validates and does not retain the key.

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

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

There is no guidance about when to use this tool instead of alternatives. The description does not mention exclusions, prerequisites, or how this relates to similar sibling tools, leaving the agent to infer usage 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does add one useful trait: the body is discarded. However, it does not disclose HTTP method, redirect handling, timeout behavior, return format, or that many input parameters are described as discarded, leaving the tool's actual network behavior largely opaque.

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

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

The description is a single, front-loaded sentence with no filler. Both clauses earn their place: they state the primary output and a key behavioral limitation. The brevity causes coverage gaps, but conciseness itself is excellent.

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 output schema and no annotations, this one-line description is far too thin. It does not state the response shape, which parameter is required/expected, whether multiple parameters are allowed, or how this tool relates to several similar sibling tools, so an agent would struggle to invoke it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds some meaning by implying that `url` is the parameter used to obtain the HTTP status and that the body is not returned, but it does not clarify the roles or relevance of the other 8 parameters or indicate which ones an agent should supply.

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 communicates the core action: return an HTTP status for a public library docs URL, and it adds that the response body is discarded. It is concise and not a tautology, though it does not explicitly name a verb or contrast itself with sibling tools like fetch-status or browser-url-ok.

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

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

There is no guidance about when to use this tool instead of alternatives such as fetch-status, web-fetch, browser-url-ok, or normalize-url. It does not mention prerequisites, exclusions, or what makes a URL eligible as a 'public library docs URL'.

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. 'Values discarded' is a useful behavioral disclosure beyond the tool name, indicating values are intentionally ignored. However, it does not describe edge cases such as nested keys, invalid input handling, or whether the count is top-level only, so transparency is incomplete.

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

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

The description is a single, front-loaded sentence with no wasted words. It states the core action and the most important behavioral qualifier ('Values discarded') 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?

The definition is adequate for a simple count operation but leaves notable gaps: no output schema or return format description, no explicit statement about which input is 'the JSON object,' and no guidance on nested key counting. The absent annotations increase the need for more context, so a mid-range score is appropriate.

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 global 'Values discarded' rule that aligns with the schema's repeated 'discarded' notes, but it does not clarify which parameter represents the JSON object to count or how the many heterogeneous parameters relate to the counting operation. It is minimally sufficient but not genuinely helpful.

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 keys in a JSON object.' The additional 'Values discarded' clarifies that values are irrelevant, helping distinguish it from siblings like validate-json or domain-shape. This is a clear, specific purpose statement.

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 purpose implies when to use the tool: when an agent needs a count of keys in a JSON object. However, there is no explicit guidance about when not to use it, no mention of alternatives, and no routing among the many sibling tools. It is acceptable but 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?

With no annotations provided, the description carries the full burden. It does disclose a meaningful behavior: 'Query and fragment are dropped.' However, it does not clarify that the schema accepts many non-URL parameters, what happens to invalid URLs, whether the operation is read-only, or what the exact output shape is, leaving significant behavioral 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?

The description is very concise and front-loaded: the first sentence states the result, and the second adds a key behavioral detail. Both sentences earn their place. However, for a tool with nine parameters and no output schema, the description is arguably too terse to be 'appropriately sized' in 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 tool has nine parameters, no annotations, and no output schema, so the description must carry significant contextual weight. It only explains what happens to a URL's query and fragment, but never mentions the roles of ref, city, feed, host, json, path, zone, or query, nor how they relate to the stated purpose. An agent cannot confidently know whether to supply only 'url' or some combination of the other parameters.

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 all nine parameters with 100% coverage, so the baseline is 3. However, the description's use of 'Query' collides with the schema's 'query' parameter, which is described as 'Search text; discarded after the length check' rather than a URL query string. The description also fails to identify 'url' as the primary parameter among the many unrelated props.

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

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

The description clearly states a specific action and result: 'Return origin, host, and path for a URL.' This distinguishes it from sibling URL-check/validation tools like browser-url-ok or domain-shape. However, it does not explicitly differentiate from closely related siblings, and the presence of many unrelated schema parameters muddies which input actually matters.

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

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

No guidance is given about when to use this tool versus alternatives such as browser-url-ok, playwright-url-ok, or web-fetch. The description does not state prerequisites, exclusions, or when the tool is the right choice, so an agent must infer usage from the name and schema alone.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses one trait (no browser is launched), but it does not explain whether a network request is made, what 'can be opened' means, what side effects or errors may occur, or what the result looks like. This is only minimal transparency.

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

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

The description is two short sentences with no fluff. The core purpose is front-loaded, and the important behavioral note about not launching a browser is included 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?

Despite having 9 optional parameters and no output schema, the description does not indicate which parameter is the primary URL, how parameters interact, or what the tool returns. This is too thin for an agent to confidently invoke the tool across the full range of possible inputs.

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

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

Schema description coverage is 100%, so the parameters are already individually documented. The tool description adds no parameter-level meaning, but the schema descriptions cover the basics, 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 uses a clear verb ('Check') and resource ('whether a URL can be opened'), and adds the meaningful qualifier 'No browser is launched.' This distinguishes it from browser-based alternatives, though it does not explicitly name a sibling or clarify whether the check is via HTTP, DNS, or URL syntax.

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

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

There is no explicit guidance on when to use this tool versus siblings like fetch-status, browser-url-ok, or web-fetch. The 'No browser is launched' line hints at one exclusion, but it does not state when this tool should be preferred or what alternatives exist for other cases.

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 transparency burden, but it only repeats the schema-level detail that the query is discarded. It does not explain what happens to the eight other unrelated schema parameters, whether they are ignored or rejected, or what the exact return value is. Since the schema already documents 'discarded after the length check', the description adds little behavioral value beyond structured 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: 'Count characters in a search query. Query discarded.' The action is front-loaded, and every word contributes either to purpose or behavioral 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?

Despite being a simple operation, the tool has a large 9-parameter schema, no output schema, and no guidance on which parameters are actually needed. The description does not reconcile why fields like `city`, `feed`, `host`, `json`, and `path` are present when the tool only counts characters in a query. An agent could be misled about how to invoke the tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3 and the description is not required to compensate. The description's mention of 'search query' roughly maps to the `query` parameter, but it adds no new semantic details beyond what the schema already says. It also fails to clarify that the other parameters are irrelevant to this tool.

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

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

The description clearly states the core operation: count characters in a search query. It is specific about the verb ('Count') and resource ('characters in a search query'), so it avoids tautology. However, it does not explicitly differentiate itself from sibling length/count-type tools like memory-key-count or hn-front-count.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives, nor any exclusion or prerequisite. An agent must infer the sole usage case from the purpose statement alone. This is below the bar for clear 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only labels the tool as a 'short catalog' and says nothing about side effects, return format, network behavior, or security implications, leaving the agent completely in the dark about what happens when the tool is invoked.

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, brief sentence and is concise without redundancy. However, it is under-specified rather than appropriately sized, and lacks any structure that would help an agent understand the tool's purpose or usage.

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 eight parameters, no annotations, and no output schema, a one-phrase description is completely inadequate. The description does not explain what the catalog contains, how to query it, what response to expect, or why such diverse inputs are accepted.

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 eight parameters have individual descriptions in the input schema, so schema coverage is high. The tool description adds no parameter-related meaning but does not need to because the schema already documents each parameter; however, it fails to explain why parameters like city, feed, and json relate to a status code catalog.

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

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

The description 'Short catalog of common HTTP status codes' simply restates the tool name and provides no verb, action, or behavioral detail. It does not differentiate the tool from sibling tools like fetch-status or compatibility, leaving an agent unsure what operation it performs with the varied inputs.

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

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

The description gives no guidance on when to use this tool versus alternatives. There is no mention of conditions, exclusions, or preferred sibling tools despite a large set of related tools such as fetch-status, web-fetch, and compatibility.

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?

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It does reveal a key behavioral trait: the tool discards the prompt and returns a fixed template. However, it does not describe side effects, error behavior, or exactly which inputs are ignored, especially since some schema descriptions like 'url' and 'host' suggest they might be used.

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

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

The description is very concise: two short sentences with no filler, and the main purpose is front-loaded. 'Prompt discarded' is compact but somewhat cryptic, which prevents a perfect score for clarity of phrasing.

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 tool with no required parameters and no output schema, the description gives the essential information: a fixed three-step template is returned and the prompt is ignored. It does not specify the actual template content or when to invoke this tool instead of similar siblings, leaving a modest but real gap.

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

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

Schema description coverage is 100%, so the baseline is 3 and the description does not need to compensate for undocumented parameters. The description adds a global hint that the prompt is discarded, implying parameters are largely irrelevant. But it does not clarify whether all nine optional parameters are ignored, and the schema contains inconsistent descriptions for url and host.

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 output ('three-step thinking template') and a clear verb ('Return'), which is enough to know what the tool does. 'Prompt discarded' also communicates that the tool does not use the provided input, helping distinguish it from the many shape-check and fetch siblings. It does not name a sibling explicitly, and 'Prompt discarded' is slightly ambiguous about whether it means the user prompt or all parameters, so it is not a 5.

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

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

There is no guidance about when to use this tool versus any of the sibling tools. No alternatives are mentioned, and no conditions or exclusions are provided. 'Prompt discarded' hints that input content is irrelevant, but that is not an explicit usage policy.

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 burden. It does disclose the core behavior (current time in a named IANA timezone) and nothing suggests side effects, but it does not state return format, error handling, or that the schema does not accept a timezone parameter.

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

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

One short sentence with no filler; the core purpose is front-loaded. It is concise, though the brevity comes at the cost of omitting invocation details.

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

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

For a tool with many optional parameters and no output schema or annotations, this description is far from complete. An agent cannot determine how to supply the required IANA timezone, making the tool effectively uncallable as described.

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 have 100% coverage, the listed parameters (ref, url, city, feed, host, json, path) are unrelated to an IANA timezone. The description introduces the concept of a named IANA timezone but never ties it to any parameter, and additionalProperties=false prevents passing a new one, leaving no usable 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 clearly states that the tool returns the current time for a named IANA timezone, which distinguishes it from siblings like utc-time and iana-zones. It is not a tautology, though it lacks an explicit verb like 'returns'.

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

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

No guidance is given about when to use timezone versus utc-time or iana-zones, and no prerequisites or exclusions are mentioned. The only use case is implied by the phrase 'named IANA timezone'.

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 annotations block contains only a topic label and no safety or mutability hints, so the description must carry the behavioral disclosure burden. It does not explain that the listed schema parameters appear to be discarded or ignored, nor does it state the output format (e.g., epoch vs. ISO 8601). The behavior is not fully disclosed beyond the basic promise of returning a current UTC timestamp.

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 sentence with no filler, which is structurally clean. However, it is under-specified for a tool with a non-obvious input schema and no output schema. It is concise but not sufficiently informative.

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

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

Given the presence of seven input parameters and no output schema or meaningful annotations, this description is too sparse. It does not explain how the parameters relate to the result, what format the timestamp takes, or whether any inputs are required. An agent is left to guess about critical invocation details.

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

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

The input schema provides descriptions for all seven parameters, including notes like 'discarded after the shape check', which gives the agent some sense of their irrelevance. The tool description itself adds no parameter-level guidance, but the schema coverage is high, so the baseline score of 3 is appropriate. No additional compensation is required from 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, although a noun phrase, clearly identifies the tool's purpose: returning the current UTC timestamp. It specifies the resource (UTC time) and the function (current timestamp), so an agent can infer what it does. It does not explicitly name a sibling for differentiation, so it falls just 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 description provides no guidance about when to use this tool versus related siblings such as timezone or iana-zones. It does not mention any exclusions, prerequisites, or alternative tools. The only implication is that one might use it when a current UTC timestamp is needed, but that is 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 burden of behavioral disclosure. It usefully notes that the body is discarded, implying a non-persistent, read-only operation, but it does not disclose what happens on invalid JSON or what the return value looks like.

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 action is front-loaded and the behavioral note is kept to a second succinct clause.

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 schema covers parameters well, but there is no output schema and the description omits return semantics, error handling, or how the body should be supplied. For a simple validator this is minimally workable but not complete.

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

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

The input schema provides descriptions for all parameters, including 'json' as 'JSON text to validate; discarded after the check'. The description adds only the generic 'body' concept without mapping it to the specific parameter, so it adds little 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 action: checking whether a body is valid JSON. This distinguishes it from sibling shape-validators, though it doesn't explicitly name or contrast any 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?

No guidance is given about when to use this tool versus alternatives, nor are any exclusions provided. The agent must infer usage solely from the tool name and 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, the description carries the full burden, but it only adds 'via Open-Meteo' as a behavioral hint. It does not disclose whether the call is read-only, how errors are handled, what units are returned, or that other schema parameters are irrelevant.

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 immediately and 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?

Without an output schema or annotations, the description should provide enough context to invoke the tool correctly, but it leaves out return format, units, and which parameter among the nine optional ones to use. The large unrelated parameter set makes this gap more serious.

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's 'for a city' correctly points to the city parameter, but it adds no format, requiredness, or clarification about the other eight optional parameters in the schema.

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

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

The description states the tool returns 'Current temperature for a city via Open-Meteo,' which names the resource (city) and the domain (weather), setting it apart from siblings like geo-hint. It lacks an explicit verb such as 'get' and does not mention the unrelated schema parameters, so it is clear but not maximally precise.

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

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

The description implies usage: call this when you need the current temperature for a city. It gives no explicit when-to-use or when-not-to-use guidance and names no alternative tools or conditions, so an agent must infer the 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 carries the behavioral disclosure burden. It usefully discloses that the body is discarded and the output is limited to status and content type, but it does not address error behavior, redirects, network side effects, or what a response looks like.

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 outcome is front-loaded and the critical 'Body discarded' 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?

The tool has 9 optional parameters, no annotations, and no output schema. The description only addresses the url case and leaves the purpose of ref, city, json, zone, query, and other parameters unexplained at the tool level, so an agent cannot reliably tell whether these are alternative inputs or ignored fields.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning, but the schema already documents the url parameter and the discarded-after-check behavior of the other optional 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 states a specific operation—returning HTTP status and content type for a public URL—and adds the key boundary that the body is discarded. It is clear about the resource and output, though it does not explicitly differentiate it from sibling tools like fetch-status or browser-url-ok.

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

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

Usage is implied: use this when only HTTP status and content type for a public URL are needed and the response body is not required. There is no explicit when-to-use/when-not-to-use guidance or mention of alternatives, despite several overlapping sibling tools.

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

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

With no annotations present, the description carries full behavioral disclosure duty. It states the core check and that the title is discarded, but it does not disclose how the result is returned, whether a network request is involved, or any error behavior. This is insufficient for a tool with no annotation coverage.

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

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

The description is short and front-loaded, with the main purpose stated first. The second sentence adds one behavioral detail, but the overall definition is under-sized for a seven-parameter tool that still needs invocation guidance.

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

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

There are seven parameters, no annotations, and no output schema, yet the description does not explain which parameter is the title, what the return value is, or how the tool should be invoked. This is fundamentally incomplete for an agent to use 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 description refers to a 'title,' but the input schema exposes ref, url, city, feed, host, json, and path, each described as unrelated to Wikipedia titles and mostly 'discarded.' An agent cannot determine which parameter, if any, should hold the Wikipedia title, and the description adds no mapping to 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 a specific action and resource: 'Check whether a Wikipedia title exists.' This distinguishes the tool from sibling tools like fetch-status or normalize-url. However, it does not explain how the title is passed, and the additional 'Title discarded after the call' clause adds some confusion.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. The only usage indication is a near-restatement of the operation: use it to check Wikipedia title existence.

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