ISO country GW

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 reveal that task text is discarded and names the return artifacts, but it does not explain how the inputs are used, whether calls incur cost, whether external network access occurs, or what happens when parameters are invalid. For a pay-per-call tool, side-effect and cost disclosure is especially important.

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

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

Two sentences with no fluff, and the core purpose is front-loaded. The mention of return artifacts and task-text handling earns its place, though the unexplained 'Monid' term costs a little clarity.

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

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

For a tool with nine optional parameters, no output schema, and no annotations, this description is too thin. It does not explain how the parameters influence the result, what 'Monid' is, whether parameters are mutually exclusive, or what the returned items look like. An agent would struggle to know which parameter to supply.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds no mapping between the nine parameters and the returned gateway/setup/hops, which is a gap, but the baseline of 3 is appropriate because the schema handles 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 specific verb and resource ('Find a public pay-per-call tool gateway (Monid)') and lists what is returned, which is clear on its face. However, it does not distinguish this tool from the many sibling utility tools, and the nine unrelated parameters muddy the purpose.

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

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

There is no guidance about when to use this tool versus siblings like web-fetch, validate-json, or timezone. The phrase 'Task text discarded' hints at an intended use case, but it never states when an agent should call this tool or what conditions make it 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?

With no annotations, the description carries the behavioral burden. It discloses one useful side-effect fact (no browser launch), but it does not say whether a network request is made, what 'can be opened' means, whether redirects are followed, or what the return value is. This is too little transparency for an operation with no annotation support.

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

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

The description is two short sentences with no filler, and the core purpose plus the key side-effect note are front-loaded. However, for a tool with nine heterogeneous parameters, it is arguably too thin to be considered ideally sized.

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

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

The tool has no output schema and no annotations, and its description does not explain which parameters are relevant, what result the agent should expect, or how 'can be opened' is determined. This makes the description incomplete for reliable tool selection and invocation.

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

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

The input schema already describes all parameters, so the baseline is 3. The description adds no parameter-level meaning and does not reconcile the URL-checking purpose with the many unrelated-looking parameters such as city, ref, json, and query, which are only explained inside the schema.

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

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

The description states a specific verb and resource: 'Check whether a URL can be opened.' Adding 'No browser is launched' helps distinguish it from browser-automation siblings. However, it never defines what 'opened' means, and it ignores the other eight parameters, leaving some scope ambiguity.

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 browser is launched' implies this is a lightweight check rather than a full browser action, giving a rough usage context. It does not explicitly name alternatives like playwright-url-ok or fetch-status, nor does it state when this tool is preferred over them.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose that the expression is discarded, suggesting no persistence, but it doesn't describe return values, failure modes, side effects, or the unusual behavior implied by the many 'discarded after check' parameters. This is a minimal behavioral signal at best.

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, which is positively concise. However, for a tool with 9 parameters and no output schema, this is under-specification rather than appropriately sized. The sentence earns its place, but crucial details are missing.

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 9-parameter schema with no explained connection to the arithmetic expression, the description is far from complete. An agent cannot determine what result to expect, how to pass the expression, or whether the other parameters are required. This is critically inadequate for reliable tool use.

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

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

Although the schema has 100% description coverage, the tool description gives no indication how any of the 9 parameters relate to an 'a+b' arithmetic expression. None of the parameters (ref, url, city, feed, host, json, path, zone, query) clearly carries the expression to evaluate. The description thus fails to add meaning beyond the schema and leaves invocation ambiguous.

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

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

The description states a concrete action, 'Evaluate a+b style arithmetic,' which is a clear verb and resource. It distinguishes itself from the sibling tools, none of which are arithmetic evaluators. However, it doesn't explicitly differentiate from alternatives through comparative language.

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

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

No guidance is provided about when to use this tool versus any sibling tool. The phrase 'Expression discarded' gives a hint about behavior, but there is no context about what inputs or conditions should lead an agent to select calc-eval. Alternatives are never 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 provided, the description carries the full burden of behavioral disclosure. It does disclose that page content is not stored, which is useful, but it omits other behavioral traits such as read-only safety, network access, permission needs, rate limits, or what happens to the supplied input parameters.

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

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

The description is one concise sentence with no filler and front-loads the primary output. It could be slightly more informative, but it is efficiently structured.

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

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

Given 9 optional parameters, no output schema, and no annotations, the description is too thin. It explains only the URL-related purpose and ignores the other parameters, the tool's relationship to many similar siblings, and the overall invocation context needed for reliable agent selection.

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

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

Schema description coverage is 100%, so the schema already documents all 9 parameters. The description adds no parameter-level meaning beyond mentioning 'URL,' but because the schema fully covers the parameters, the baseline of 3 is appropriate.

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

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

The description states a specific operation: 'Return host, scheme, and HTTP status for a URL.' This is a clear verb+resource statement. It does not, however, differentiate the tool from siblings like fetch-status or normalize-url, which likely overlap in purpose.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor does it mention any exclusions or preferred conditions. The context is implied at best ('for a URL'), but there is no explicit when-to-use or when-not-to-use guidance.

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

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

The description adds one useful behavioral note ('No identifiers are retained'), which signals privacy. However, with no annotations provided, it does not disclose whether the tool performs external calls, whether it is read-only, what side effects occur, or how the provided fields are consumed beyond being discarded.

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

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

The description is a single efficient sentence with no wasted words. However, it is so sparse that it borders on under-specification rather than effective conciseness, failing to convey essential operational 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?

Given 9 optional parameters, no output schema, and no annotations, this description is severely incomplete. It does not explain what classification output to expect, how to select or combine parameters, what the tool is for, or how it relates to sibling tools.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself adds no parameter-level meaning beyond what the schema already provides; it only reinforces the discard behavior for identifiers, which is already stated in several 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 says the tool will 'Show how this request is classified', but it never defines what classification means, what categories are produced, or what 'this request' refers to. The resource and outcome are ambiguous, and the description does not distinguish this tool from its many siblings.

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

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

There is no guidance on when to use this tool, what kind of request or input is appropriate, or which sibling tool should be used instead. With 26 sibling tools such as domain-shape, jira-key-shape, and validate-json, the absence of any selection guidance is a significant gap.

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

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

With no annotations, the description carries the full transparency burden. It does disclose a meaningful behavioral trait: no WHOIS or ownership lookup. However, it does not mention side effects, network access, return format, or edge-case behavior, so transparency is only partially complete.

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 efficient sentence with the core action front-loaded and no filler. It loses one point because, given the nine-parameter schema and missing output schema, the description is borderline under-specified rather than ideally complete.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, this description is under-specified. It does not state what the output looks like, which parameters are actually used for the hostname split, or what happens when invalid or mismatched input is provided.

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 little beyond indicating that a hostname is the relevant input, and it does not explain why the schema also includes eight unrelated optional 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 specific action and resource: split a hostname into labels. It also adds an explicit non-goal, 'without WHOIS or ownership data,' which distinguishes it from lookup-style tools. It is not a tautology and reads clearly for an agent looking for domain/hostname structure.

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 mostly implied: if an agent needs hostname labels, this is the tool to use. The 'without WHOIS or ownership data' phrase provides a negative boundary, but no explicit when-to-use/when-not-to-use guidance or alternative sibling tools 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 must carry the behavioral burden. It discloses the HTTP method and minimal return value, but it does not explain that most inputs are 'discarded after the shape check', that there is no disk access, or what the status output actually looks like. The mismatch between the narrow description and the broad schema further obscures 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 a single, front-loaded sentence with no filler. It communicates the core action efficiently, although the under-specification relative to the schema prevents a higher score.

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 addresses one action. It does not explain return value format, what 'status only' means, how to choose among the many accepted inputs, or how this fits with the sibling tools. This is far from complete for the schema's 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 the baseline is 3. The description adds no parameter-level meaning beyond the schema, and it fails to indicate which parameter is primary or how the unrelated parameters relate to the stated purpose, but the schema itself documents each parameter.

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

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

The description states a specific operation, 'HEAD a public URL and return status only', but the input schema accepts nine unrelated optional parameters such as city, json, path, zone, and query. This makes the actual purpose ambiguous and misleading: an agent cannot tell whether this tool is a URL HEAD checker or a generic shape/status checker for many input types.

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

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

There is no guidance on when to use this tool versus its siblings like web-fetch, browser-url-ok, playwright-url-ok, normalize-url, or status-catalog. The phrase 'return status only' gives a faint usage hint, but no exclusions, alternatives, or selection criteria are provided.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose one useful trait: 'Path discarded.' But it does not say whether the tool is read-only, whether it performs network access, what it returns, or whether it validates against a known Figma URL pattern. For a parse/shape operation with no output schema, this is a significant transparency 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 very short and front-loaded: two sentences, no filler. It earns its place by naming the resource and the one behavioral constraint. However, 'Path discarded' is terse enough to be ambiguous—whether it means the URL path component or the 'path' input parameter—so it is not a perfect 5.

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

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

There is no output schema and no annotations, so the description is the only source for return behavior and side effects. It omits what the parse result looks like, whether the input must be a full HTTPS Figma URL, and how this tool relates to siblings like normalize-url or browser-url-ok. The schema descriptions cover parameter names, but not the operational context an agent needs to confidently invoke this 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 baseline is 3. The description adds no parameter meaning beyond what the schema already provides, and it does not clarify why there are 9 unrelated parameters or which one should receive the Figma URL. It neither helps nor harms beyond the schema's own 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 specific verb and resource: 'Parse a Figma file URL.' This is enough to identify the tool as Figma-specific and to distinguish it from generic URL tools like normalize-url or browser-url-ok. However, it does not explicitly differentiate itself from sibling shape-checking tools or explain whether it validates, extracts, or normalizes.

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

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

Usage is implied: an agent should use this when it needs to parse a Figma file URL. But the description gives no explicit when-to-use versus alternatives, no exclusions, and no guidance about which input parameter is the operative one among the 9 schema properties.

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 meaningful trait—'No disk access'—which helps the agent understand side effects and safety. However, it does not explain what 'looks safe' means, what criteria are checked, or what the tool returns, leaving important behavioral details 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?

Two short sentences with zero filler. The core claim is front-loaded, and the critical 'No disk access' caveat is placed immediately after, making the description easy to scan and understand.

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 parameters, no annotations, and no output schema, this terse description leaves significant gaps: it does not clarify which parameters are relevant, whether this is a boolean check, or what 'safe' means. An agent selecting and invoking this tool from the broader sibling family would need more context than this provides.

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; all parameters already have individual descriptions. The tool description itself adds no further parameter-level meaning and does not clarify how the nine optional parameters relate to the stated 'path' focus, but it also does not contradict 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 ('Check whether a path looks safe') and resource ('a path'), and 'No disk access' adds a useful scope boundary. It does not explicitly name or compare against sibling validators like browser-url-ok or wiki-title-ok, so it misses the top score for sibling differentiation.

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

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

There is no guidance on when to use this tool versus alternatives, no exclusions, and no conditions such as 'use normalize-url for URLs.' The intended use case is only implied by the name and the word 'path,' which is not enough for an agent choosing among many sibling shape-check 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, but it only reveals that Open-Meteo is the source and that coordinates are returned. It does not disclose the output format, failure behavior, rate limits, or that many input parameters are ignored/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, front-loaded sentence with no filler. Every word contributes to identifying the tool's core function.

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 nine optional parameters and no output schema or annotations, the description only states the general purpose. It fails to tell the agent which parameter to provide for the place, what the return value looks like, or what happens when the place cannot be resolved. This is inadequate for 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 coverage is 100%, so the baseline is 3; the description adds the idea that a 'place' is the subject but does not map it to a specific parameter, leaving ambiguity among city, host, zone, and query.

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 provides latitude and longitude for a place via Open-Meteo, naming a specific resource and external source. It lacks an explicit verb and does not contrast with sibling hint tools, so it doesn't fully earn 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 geo-hint versus weather-hint, timezone, or other sibling tools, and no mention of when not to use it. The phrase 'for a place' implies use when coordinates are needed, but the agent is left to infer the trigger and the correct input parameter.

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

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

No annotations are provided, so the description carries the full burden. It only says 'parse', without disclosing error behavior, whether it validates the URL, whether other parameters are ignored, or what the output format looks like. The schema's many 'discarded' parameters suggest notable behavior that the description does not address.

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 efficient sentence with no filler and the core action is front-loaded. It earns its place, though it sacrifices useful context 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?

For a tool with 9 parameters, 0 required, no output schema, and no annotations, this description is under-specified. An agent cannot determine which parameter to fill, what the tool returns, or how invalid GitHub URLs are handled.

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 slight meaning by tying the purpose to GitHub URLs, which helps identify `url` as the relevant parameter, but it does not clarify the roles of the other eight parameters or which ones are actually needed.

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'), making the tool's job unambiguous. It also distinguishes this tool from sibling shape tools like figma-url-shape and jira-key-shape by scoping it to GitHub URLs.

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 is implied: use this when you need to parse owner and repo from a GitHub URL. However, it does not explicitly say when not to use it or name alternatives such as normalize-url or other shape 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 for behavioral disclosure. It reveals that titles are discarded, but it does not explain whether the tool fetches live data, which parameters affect the count, what the response contains, or whether it is read-only. This is insufficient for a tool with nine optional parameters.

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

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

The description is two short sentences with no filler, and the primary action is front-loaded. It is concise and easy to scan, even though it is sparse.

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

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

There is no output schema and no annotations, and the tool has a nine-parameter optional schema. The description should clarify input relevance and return shape, but it only states the count behavior and title-discarding, leaving the role of the other parameters and the output format unspecified.

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 only echoes the feed parameter's 'titles discarded' note and does not clarify which of the nine optional parameters are used for the count or how they 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 states a clear action and resource: 'Count current Hacker News front-page stories.' It also adds a useful trimming detail, 'Titles discarded.' However, it does not differentiate from sibling tools, and the large optional input schema creates ambiguity about which parameters are actually relevant.

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 on when to use this tool versus alternatives like web-fetch, fetch-status, or the various shape-check siblings. There is no mention of context, exclusions, or preferred scenarios.

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 of behavioral disclosure. It does not state that inputs are discarded, that the operation is read-only, what the return value looks like, or why arbitrary parameters are accepted. The schema hints at discarding behavior, but the description itself reveals nothing.

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 efficient fragment with no wasted words and the key noun phrase front-loaded. However, it is so minimal that it borders on under-specification rather than conciseness, lacking any verb or behavioral anchor to structure the agent's mental model.

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, no annotations, and no output schema, the description needs to explain what the tool returns and how the parameters relate to the call; it does neither beyond vaguely implying a list of timezone names. The mismatch between the stated purpose and the parameter list makes the definition incomplete for reliable invocation.

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

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

Schema description coverage is 100%, so the baseline of 3 applies; every one of the 9 parameters has an individual description, including the note that values are discarded. The tool description adds no parameter-level meaning and fails to explain why these parameters appear on a timezone-names tool, but the schema itself carries the semantics.

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

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

The description, 'Common IANA timezone names for clock calls,' is a near-restatement of the tool name (iana-zones) with only a vague nod to clock-related usage. It lacks an action verb, and the 9 input parameters (Git refs, URLs, JSON, file paths) bear no evident relationship to timezone names, leaving the agent confused about what the tool actually 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?

The only usage signal is the phrase 'for clock calls,' which weakly implies a link to sibling clock tools like timezone and utc-time. There are no explicit conditions, when-not-to-use guidance, or named alternatives, so the agent receives no practical decision support for choosing 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 carries the burden of explaining behavior. It clarifies that the operation fetches a public resource and returns only group counts, setting expectations about scope and output. It is concise but does not address edge cases like missing robots.txt or redirects, which keeps it a step below a 5.

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 no filler. It front-loads the main action and ends with the key output constraint, making it easy to parse.

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

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

Given 9 optional parameters, no required parameters, no annotations, and no output schema, the description is too sparse to fully support correct invocation. It explains the general purpose but not which parameter to populate or what the returned group counts look like in practice.

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

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

The schema covers 100% of parameters with descriptions, but those descriptions are generic and largely unrelated to robots.txt, mentioning city, feed, json, and discarded values. The tool description does not say whether to pass 'host', 'url', or another parameter, so an agent cannot reliably determine the correct argument for fetching robots.txt.

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

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

The description states a specific verb and resource: fetch a public robots.txt. It also narrows the output to 'group counts only,' which clearly distinguishes it from generic fetch tools like web-fetch or fetch-status. An agent can tell what this tool is for.

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

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

There is no guidance on when to use this tool versus alternatives, and no exclusions or conditions are stated. The description implies a use case but does not help the agent choose between inspect-robots and related siblings like web-fetch or fetch-status.

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

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

No annotations are provided, so the description carries the full burden. It adds the note 'Key discarded,' which suggests the input is not retained, but it does not disclose the return value, side effects, error behavior, or whether the check is purely local. This is insufficient for an agent to predict tool 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 only two short sentences and is front-loaded with the core purpose. There is no filler or redundancy. It could be less terse, but it earns its 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 mismatched input schema, the description does not provide enough context to safely invoke the tool. It fails to identify the key parameter, explain the shape rules, or describe the result, making the tool effectively unusable as documented.

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

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

The schema contains eight properties (ref, url, city, feed, host, json, path) but no property representing a Jira key. The schema descriptions point to unrelated concerns like Git refs, weather, RSS, JSON validation, and file paths. The description's mention of 'key' does not map to any parameter, so an agent cannot determine which input 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 specific verb and resource: 'Check a Jira issue key shape.' This distinguishes it from sibling shape-checkers like github-repo-shape or domain-shape. However, 'Key discarded' is ambiguous about whether the tool returns a result or simply consumes the input, and the description gives no indication of what a valid shape looks like.

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 github-repo-shape, domain-shape, or wiki-title-ok. The purpose is implied by the name, but the description contains no conditions, exclusions, 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?

With no annotations, the description carries the burden, and it does disclose the key behavior: only the HTTP status is returned and the body is discarded. It does not mention redirects, timeouts, or error behavior, but for a read-only status check the core behavior is reasonably transparent.

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

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

The description is two short sentences with no filler, and the main purpose is front-loaded. It could be more informative, but as a concise statement it earns its length.

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

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

With no output schema, no annotations, and 9 optional parameters, a two-sentence description is not enough. It does not specify the response format, which parameter(s) to provide, or how this tool differs from closely related siblings, leaving important operational details implicit.

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 documents all 9 parameters, so the baseline is 3, but the description adds confusion rather than clarity: it refers to a 'public library docs URL' while the schema's url parameter is described as 'HTTPS URL to normalize or cite.' It also fails to explain how the many optional parameters relate or which one is the primary 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 a concrete result: an HTTP status for a docs URL, and explicitly says the body is discarded. This gives the agent a clear sense of the tool's job and distinguishes it from tools that fetch content. However, 'public library docs URL' is somewhat ambiguous between a physical library's docs and software-library documentation.

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 prefer this tool over closely related siblings such as fetch-status, browser-url-ok, or web-fetch. The description does not mention alternatives, conditions, or exclusions, so an agent must guess which status-check tool to invoke.

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 and does disclose an important behavior: values are discarded. However, it does not clarify whether keys are counted at the top level only or recursively, whether JSON validation happens first, or whether anything is retained despite the 'memory' in the tool name.

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 main action is front-loaded, and 'Values discarded' earns its place as a meaningful behavioral clarification.

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

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

There is no output schema and no return-value description, leaving an agent unsure whether the result is a number, an object, or a structured response. The many optional parameters and lack of clarity about which one supplies the JSON object make the description incomplete for reliable invocation.

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

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

All nine parameters have schema descriptions, so the baseline is 3. The description adds little beyond identifying the JSON-object counting intent, but it does not explicitly map the 'json' parameter as the operative input or explain that the other parameters are ignored.

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' and clarifies that values are not used. This distinguishes it from nearby validation tools such as validate-json and from search/query-length 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 choose this tool over alternatives, nor are any exclusions or sibling comparisons provided. The description implies counting but does not say when validate-json or other shape-check tools would be more 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?

No annotations are provided, so the description carries the full behavioral disclosure burden. It does reveal that query and fragment are dropped and that the output consists of origin, host, and path. However, it does not describe error behavior, whether any network activity occurs, or how the many seemingly unrelated schema parameters are handled beyond what the schema itself says.

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

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

The description consists of two brief, front-loaded sentences with no filler. The primary outcome is stated immediately, and the dropped components are specified in the second sentence. 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?

Given 9 optional parameters, no annotations, and no output schema, the description is not complete enough for confident invocation. It does not explain how to treat the non-URL parameters, what happens when the URL is invalid, or what the exact return structure looks like. The schema covers individual parameter descriptions, but the overall call contract remains ambiguous.

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 little parameter-level meaning: it implies the url parameter is central but does not clarify the roles of parameters like city, feed, json, ref, or zone. The parameter descriptions in the schema already carry most of the weight.

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: normalize a URL and return origin, host, and path. It also clarifies that query and fragment are dropped, which makes the core behavior distinctive from URL-checking and fetching siblings. However, it does not explicitly name or differentiate any sibling tool, so it falls 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 about when to use this tool versus alternatives. The sibling list includes several URL-related tools such as browser-url-ok, web-fetch, and domain-shape, but the description provides no conditions, exclusions, or hints for choosing normalize-url over them.

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 behavioral burden. It does disclose a key trait: no browser is launched, and the schema notes that many parameters are discarded after checks. However, it does not state whether a network request is made, what side effects may occur, or what 'opened' means, 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 short and front-loaded, with the main action in the first sentence and an important caveat in the second. It has no filler, but it is slightly under-sized for a tool with nine parameters and no output schema, so it does not fully earn a 5.

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

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

With no output schema and no annotations, the agent is left without a stated return value or behavioral contract. The description does not explain what the tool returns, which of the many optional parameters matter, or how it differs from web-fetch and browser-url-ok beyond the no-browser note. This is too little context for confident selection and 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 all nine parameters are already documented in the schema. The description itself adds no parameter-level meaning, which matches the baseline score. A few schema descriptions add discard-related behavior, but they do not clarify which parameter is the primary input or how 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 names a specific action and resource: 'Check whether a URL can be opened.' It also adds a distinguishing caveat, 'No browser is launched,' which helps separate it from browser-url-ok. It is not a 5 because 'can be opened' is left vague and the nine unrelated input parameters muddy the tool's true 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 implies the use case: verifying URL openability without launching a browser. It does not explicitly name alternatives such as browser-url-ok or web-fetch, nor does it state when not to use this tool, so the guidance remains implicit rather than explicit.

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

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

With no annotations, the description carries the burden of behavioral disclosure. 'Query discarded' is a useful side-effect disclosure, but the description does not explain the return value, behavior with no input, or whether only the 'query' parameter is used.

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

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

The description is two short, front-loaded sentences. Both sentences add information: what the tool does and a key side effect. There is 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?

The tool has no output schema, no annotations, and nine optional parameters, but the description does not specify return format, default behavior, or how to choose the correct input. An agent is left uncertain about what to pass and what to expect back.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters. The description adds no parameter-level meaning and leaves ambiguity about which parameter should be populated, though the 'query' parameter's schema text is reasonably clear.

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 verb and resource ('Count characters in a search query') and adds that the query is discarded. It is clear about the core operation, though it does not explicitly distinguish itself from sibling length/shape-checking 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 prefer this tool over alternatives, no mention of which parameter is the search query, and no exclusion criteria. The intended use is only implied by the name and description.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that a catalog exists and says nothing about input handling, output format, side effects, or what the tool actually does with any of its parameters. This is effectively no behavioral 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 concise in word count, but it is under-specified: a short noun phrase that spends no words on behavior, parameters, or output. Brevity here is not efficient, it is empty, and it fails to provide the structural information an agent 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?

With no output schema, no annotations, and seven heterogeneous parameters, the description is far too thin. An agent cannot determine what the tool returns, how the parameters are used, or why they belong in an HTTP status catalog. The definition is not callable with confidence.

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 notable notes like 'discarded after the shape check' and 'titles discarded.' However, the tool description itself adds no parameter-level meaning and does not explain how these heterogeneous inputs relate to an HTTP status code catalog, creating confusion rather than clarity. Schema coverage is high, so a baseline of 3 is appropriate, but the mismatch prevents a higher score.

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

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

The description is a noun phrase that essentially restates the tool name: 'status-catalog' becomes 'catalog of common HTTP status codes.' It adds 'HTTP' and 'common' but lacks a verb or stated action, so it does not clarify whether the tool lists codes, looks them up, validates them, or maps inputs to them. It also does not distinguish it from sibling tools like fetch-status or compatibility.

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

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

There is no guidance on when to use this tool versus alternatives such as fetch-status, web-fetch, validate-json, or other sibling validators. The description gives no context about the expected use case, preconditions, or when it should be avoided, leaving the agent without a basis for tool 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?

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It does state that the prompt is discarded, which is useful, but it fails to disclose that the tool likely returns a static template and does not perform real normalization, validation, or citation work despite accepting parameters like url and json.

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, with two short sentences. The main purpose is front-loaded. However, 'Prompt discarded' is somewhat cryptic and could be clarified without adding much length.

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

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

The tool accepts seven diverse parameters and has no output schema, yet the description only says it returns a template and discards the prompt. It does not explain what the template looks like, why these parameters exist, or whether any parameter influences the output. This is under-specified for an agent 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?

The input schema already provides descriptions for all seven parameters, so schema coverage is complete. The description itself adds no parameter-specific meaning beyond the cryptic 'Prompt discarded,' which does not clarify how parameters relate to the returned template. 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 states a specific verb and resource: 'Return a three-step thinking template.' This is clearly distinct from sibling tools like normalize-url or validate-json. The additional 'Prompt discarded' hints at behavior without confusing the core purpose.

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

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

The description implies the tool is used when a three-step thinking template is needed, but it does not explicitly state when to use it versus alternatives or when not to use it. 'Prompt discarded' suggests it should not be used for actual thinking operations, but this is left for the agent to infer.

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

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

No annotations are provided, so the description carries the full burden. It states the core behavior—returns the current time—but does not disclose error handling for invalid timezone names, the output format, or whether network access is required. The tool appears safe/read-only by nature, so no side effects are hidden, but additional behavioral detail would improve 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 a single, front-loaded sentence with no filler. Every word contributes to the core purpose, and it is appropriately sized for the tool's 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?

The tool has a 9-parameter schema and no output schema. The description explains the return value ('current time') and the schema covers parameter semantics, including which parameter is the timezone name. Missing are explicit notes that only 'zone' is used and what happens on invalid input, but the schema's 'discarded' descriptions mitigate confusion.

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

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

The schema has 100% parameter description coverage, including 'zone' described as 'IANA timezone name'. The description adds no parameter-level meaning beyond what the schema already provides, 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 'Current time in a named IANA timezone' clearly states the verb (current time) and resource (named IANA timezone), making the tool's purpose unambiguous. It implicitly distinguishes from siblings like utc-time (no named zone) and iana-zones (lists zones rather than reporting time), though it doesn't 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 provides no guidance on when to use this tool versus alternatives such as utc-time or iana-zones. It lacks any exclusions, prerequisites, or context about which parameter to supply, leaving selection entirely to inference.

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

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

With no annotations, the description must carry the behavioral burden, but it only states what the tool returns. It does not disclose that all input parameters are ignored, whether the call is read-only, or any side effects. The schema hints some parameters are discarded, but the description itself provides no behavioral context.

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

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

The description is extremely short with no wasted words, which is concise. However, it is under-specified: it omits an action verb and provides no structural context. It is less informative than typical 4-scoring descriptions like 'Update shared drive settings...'.

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 tool, the schema has seven parameters that appear unrelated to UTC time. The description does not clarify that these parameters are optional or ignored, leaving an agent uncertain how to call the tool correctly. There is no output schema to compensate, so the description is incomplete.

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 includes descriptions for all seven parameters, so schema description coverage is high. The tool description adds no additional meaning about parameters and does not explicitly state they are irrelevant, but the schema already documents each parameter's purpose. This meets the baseline of 3.

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

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

The description 'Current UTC timestamp' clearly states the tool's output and resource. It is not a bare tautology because it specifies 'timestamp' rather than just repeating the tool name. However, it lacks a verb and does not differentiate from sibling tools like 'timezone' or 'iana-zones' which also deal with time.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention any prerequisites, exclusions, or alternative tools. An agent must infer when to call this over the similar 'timezone' or 'iana-zones' 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 supplied, so the description carries the behavioral disclosure burden. It explicitly says the body is discarded, signaling a non-persistent, side-effect-light operation. It does not describe output or error behavior, but the safety-relevant trait is clearly disclosed.

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

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

Two short sentences with no filler: the action is front-loaded and the discard behavior follows immediately. 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?

With no output schema or annotations, the description should ideally explain the return/error contract and precisely connect 'body' to a parameter; it does neither. However, the parameter descriptions are sufficient for an agent 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?

All input schema properties already have individual descriptions, so schema coverage is high and the baseline is 3. The tool description adds no parameter-level meaning and leaves the 'body' vs json mapping to the schema description.

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

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

The description uses a specific verb ('Check') and resource ('whether a body is valid JSON'), making the tool's core function immediate and distinct from the sibling URL, file, and token validators. The purpose is unmistakable even before 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 the tool should be used when JSON validation is needed, but it gives no explicit when-to-use or when-not-to-use guidance and does not name alternatives. The intended usage is inferable rather than stated.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It does not state whether the operation is read-only, whether inputs are discarded, what external API behavior or rate limits apply, or what happens on invalid city input. The schema parameter descriptions mention that values are discarded, but the main description itself does not disclose these important behaviors.

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 words. Every word contributes to identifying the tool's purpose. It is as concise as possible while still naming the resource, the operand, and the data source.

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 9 optional parameters, no output schema, and no annotations, the description is far too minimal to be complete. It only names city as relevant and leaves the agent to guess whether other parameters are usable, ignored, or even harmful. It also does not describe the return format, units, or error behavior.

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

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

Schema description coverage is 100%, so the baseline is 3. The main description adds little beyond the schema: it identifies 'city' as the relevant parameter for temperature, but the schema already describes 'city' as 'City name for a public weather hint'. It does not add format, requiredness, or clarify whether any of the other eight parameters 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 description clearly identifies the resource and action: current temperature for a city via Open-Meteo. While it does not use an explicit verb like 'gets' or 'returns', the intent is immediately clear. It also distinguishes this tool from sibling tools such as geo-hint by naming the weather-specific purpose and data source.

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

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

The description implies when to use the tool: when a current temperature for a city is needed. However, it does not explicitly mention when not to use it or point to any sibling alternative, such as geo-hint or web-fetch. There is no guidance for handling cases where multiple parameters are provided.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It does disclose the most important quirk: the body is discarded, so callers should not expect content. It does not cover auth, redirects, timeouts, or non-public URL behavior, but the key behavior is 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 description is concise and front-loaded: the core function is stated first, followed by the important body-discarded caveat. It wastes no words, though it is slightly undersized relative to the complexity of the 9-parameter 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?

The description is not complete enough for a tool with 9 optional parameters, no annotations, and no output schema. It explains what is returned but not how to specify the target URL or what the many other parameters mean for invocation, leaving an agent uncertain how to call the tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds little meaning beyond the schema, and with 9 optional parameters and no required markers, it does not clarify which parameter should actually hold the public 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 clearly states a specific operation: return HTTP status and content type for a public URL. The added 'Body discarded' note gives a useful behavioral qualifier. It does not explicitly differentiate from sibling tools like fetch-status, but the core purpose is unambiguous.

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

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

The phrase 'public URL' and 'Body discarded' imply this is for lightweight status/content-type checks where the body is not needed. However, it does not name alternatives or give explicit when-to-use versus when-not-to-use guidance, especially given many URL-related sibling tools.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It mentions that the title is 'discarded after the call,' but the schema does not accept a title, and no information is given about side effects, errors, rate limits, or how the tool actually operates. The mismatch between description and schema actively misleads the agent.

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, but the second sentence ('Title discarded after the call') references a non-existent input and adds no real value. While concise, the structure does not accommodate the schema's complexity and contains misleading repetition.

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

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

The tool has seven parameters, no output schema, and no annotations, yet the description covers only a phantom 'title.' It gives no information about return values, error cases, which parameter to use, or when to invoke it. The description is severely incomplete for the tool's actual interface.

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 descriptions cover all seven parameters, so the baseline for this dimension is 3. However, the tool description introduces a nonexistent 'title' concept and contradicts the actual parameters (ref, url, city, etc.), providing negative value. It fails to clarify which parameter carries the Wikipedia title or how the listed fields relate to the described purpose.

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

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

The description states a clear verb and resource ('Check whether a Wikipedia title exists'), but the input schema contains no 'title' parameter and instead lists unrelated fields such as ref, url, city, feed, host, json, and path. This mismatch makes the tool's actual purpose ambiguous and fails to distinguish it from sibling OK/check tools like browser-url-ok or validate-json.

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

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

The description offers no guidance on when to use this tool versus alternatives. It does not mention required inputs, contexts, exclusions, or any conditions that would lead an agent to select this tool over related shape-checking siblings.

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