ISO country NR

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

With no annotations, the description carries the full burden. It does disclose a read-like behavior, an explicit return payload list, and the fact that task text is discarded. However, it does not mention network behavior, authentication, cost implications of 'pay-per-call', output format, or any side effects beyond discard.

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 terse sentences with no filler. The main purpose is front-loaded, and the discard warning earns its place as a 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?

Despite 9 optional parameters, the description does not explain how those parameters relate to the returned artifacts, what should be passed in a typical call, or what a successful response looks like. There is no output schema and no annotations, so the invocation contract is too underspecified for an agent to confidently use the tool.

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

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

Schema description coverage is 100%, so the baseline is 3; every parameter already has a description and several include discard semantics. The tool description itself adds no parameter-level meaning beyond what the schema already provides.

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

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

The description uses a specific verb ('Find') and names a precise resource ('public pay-per-call tool gateway (Monid)'), followed by the returned artifacts: CLI setup, how-it-works, skill file, and remote MCP hops. This clearly distinguishes it from the sibling utility tools, though 'Monid' and the tool name 'agent-tool-index' are never reconciled.

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

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

Usage context is implied by the resource type being searched, but there is no explicit when-to-use or when-not-to-use guidance, no mention of alternatives, and no conditions for selecting this tool over siblings. The 'Task text discarded' note gives a negative hint, but not enough to be fully prescriptive.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It reveals one trait, that no browser is launched, but leaves unclear whether a network request is made, what side effects exist, what the return value looks like, or why several parameters are 'discarded after the call.'

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

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

Two short sentences with no wasted words; the main action is front-loaded and the caveat follows immediately. This is appropriately sized for what it communicates.

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 heterogeneous parameters, no annotations, and no output schema, so a complete description would need to explain return behavior and how the parameters map to the tool's purpose. The description does neither, and the unrelated-looking parameters create ambiguity about what the tool actually checks.

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 high schema coverage means the description is not required to restate them. The description adds no parameter-level meaning and fails to explain how the URL parameter relates to ref, city, feed, host, json, and path, but the schema text does provide partial semantic coverage.

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

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

The description states a specific action ('Check whether a URL can be opened') and an important qualifier ('No browser is launched'), so the core operation is clear. It does not, however, differentiate this tool from siblings like fetch-status or playwright-url-ok, and the schema includes non-URL params (ref, city, json, path) that the description does not reconcile.

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 lighter-weight alternative to browser-driven checks, but no sibling tool or explicit when-to-use/when-not-to-use guidance is provided. The usage intent is implied rather than stated, leaving the agent to guess when this is preferable to normalize-url, fetch-status, or playwright-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, the description must disclose side effects, return behavior, and safety characteristics; it only says the expression is discarded. It never states whether the result is returned, whether evaluation is read-only, or whether any state changes occur.

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

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

The text is short and front-loaded, but the second sentence is cryptic rather than clarifying; for a tool with nine heterogeneous parameters this is under-specification, not 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?

There is no output schema, no annotations, and no mapping from the described arithmetic evaluation to any input property. An agent cannot determine how to construct a valid call.

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

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

Schema coverage is 100%, so the baseline is 3: the description need not repeat parameter explanations. The description still fails to tie 'a+b style arithmetic' to any of the nine parameters, so it adds no operational parameter 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 first sentence names a concrete operation, 'Evaluate a+b style arithmetic', so the purpose is identifiable. But the follow-up 'Expression discarded' is unexplained and the schema exposes no expression parameter, leaving the actual object of evaluation 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?

No guidance is given for when to use calc-eval versus any sibling tool, and no alternative or exclusion is mentioned. The sentence 'Expression discarded' hints at behavior but not at selection criteria.

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

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

With no annotations, the description carries the behavioral burden. It adds one useful guarantee: 'Page content is not stored.' However, it does not disclose whether a live network request is made, how failures are handled, or any rate-limit or timeout behavior.

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

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

Two short, front-loaded sentences with no filler. The core purpose is stated first, and the privacy note adds meaningful behavioral context without repeating 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?

For a tool with nine optional parameters, no output schema, no annotations, and several sibling tools with overlapping behaviors, this description is under-specified. An agent would struggle to choose it over fetch-status or know which parameters are relevant.

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?

Parameter schema coverage is 100%, so the baseline applies. The description reinforces that the operation is about a URL but does not clarify how the eight other parameters relate to the tool or which ones should be provided.

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

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

The description clearly states the specific operation: 'Return host, scheme, and HTTP status for a URL.' This is a clear verb plus resource. It does not explicitly differentiate from sibling tools like fetch-status or normalize-url, so it does not 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?

The description provides no guidance about when to use this tool instead of overlapping siblings such as fetch-status, normalize-url, or web-fetch. There are no conditions, exclusions, or alternative tool suggestions.

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. 'No identifiers are retained' is one useful behavioral detail, but the description does not disclose output format, side effects, how inputs are combined, or whether anything is fetched or stored.

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 front-loads its core action. Both sentences are concise, though the first is too vague to be maximally useful.

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 nine-parameter tool with no output schema and no annotations, this description is severely incomplete. It fails to explain what classification is returned, how to pick parameters, or what the tool is for, so an agent cannot confidently select and invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already documents each parameter and its discard behavior. The description adds only the general 'No identifiers are retained' promise, not parameter-specific meaning 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 gives a verb ('show') and a subject ('how this request is classified'), so it is not a pure tautology, but it never says what classification scheme is being applied or what the tool returns. With nine heterogeneous optional parameters, an agent cannot tell what 'compatibility' means or how the inputs relate to the output.

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 instead of a sibling such as validate-json, normalize-url, timezone, or file-path-ok. No conditions, alternatives, or exclusions are provided.

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

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

With no annotations, the description carries the transparency burden and does add one useful behavioral boundary: it performs only syntactic splitting and does not fetch WHOIS/ownership information. However, it does not describe the output format, error behavior, or whether other input fields (url, path, json, etc.) are ignored, so disclosure 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?

A single, front-loaded sentence that wastes no words: the action ('split'), object ('hostname'), and key limitation ('without WHOIS or ownership data') are all present. It is appropriately sized for a simple shape tool.

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

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

The description is incomplete relative to the actual schema. With nine optional parameters, no required fields, and no output schema, the agent gets no guidance on which parameter to populate or why the unrelated fields (city, feed, json, path, zone, query) exist. The description also omits the return shape of the split labels.

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

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

Schema coverage is 100% and every parameter has a description, so the baseline is 3. The tool description itself adds no parameter-level meaning and, if anything, creates ambiguity by mentioning only 'hostname' while the schema exposes nine unrelated 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 verb and resource ('Split a hostname into labels') and adds a clear scope limitation ('without WHOIS or ownership data'), so an agent can tell this is syntactic hostname parsing rather than an ownership lookup. It does not explicitly name a sibling alternative, so it stops short of a 5.

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

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

It implies when to use: any time labels from a hostname are needed, and the 'without WHOIS or ownership data' phrase gives an explicit exclusion for ownership-related requests. It does not name an alternative tool, so it lacks the full when/when-not/alternative guidance needed for a 5.

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 usefully discloses the HTTP method (HEAD), that the URL must be public, and that only status is returned. With no annotations, it still leaves out failure behavior, redirect/timeout handling, rate limits, and what happens when unrelated schema fields are supplied.

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 earns its place by stating the method, target, and output scope as concisely as possible.

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, nine optional parameters, and several close sibling tools, this one-sentence description is incomplete. An agent cannot tell the return value shape, how the various parameters interact, or how fetch-status differs from the sibling URL-checking 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 high, but the tool description commits to a single URL input while the schema exposes eight other optional inputs with 'discarded' semantics, such as city, json, path, query, and zone. The description does not clarify which parameter drives the HEAD request or what the remaining parameters are for, so it actively narrows and obscures the actual parameter surface.

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 (HEAD), a clear resource type (public URL), and a narrow outcome (status only). It is not a tautology and reads clearly, but it does not distinguish fetch-status from close siblings such as browser-url-ok or web-fetch.

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

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

There is no guidance about when to choose this tool over alternatives like browser-url-ok, playwright-url-ok, normalize-url, or web-fetch. 'Return status only' implies a lightweight check, but no explicit when/when-not or alternative routing is provided.

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

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

With no annotations, the description must disclose behavior itself. It does state one useful behavioral trait: the path is discarded. However, it does not reveal what the tool returns, how invalid URLs are handled, or whether any network interaction occurs, so transparency is only partial.

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

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

The description is two short, front-loaded sentences with no redundancy. Both 'Parse a Figma file URL' and 'Path discarded' carry useful information and earn their place.

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

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

Despite a detailed input schema, the tool has no output schema, no annotations, and nine optional parameters. The description does not explain the return value, the practical relationship between 'url' and 'path', or when this tool should be preferred, leaving too much for the agent to infer.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds only minimal meaning beyond the schema, such as clarifying that the input is a Figma file URL and that the path is ignored; it does not add meaningful syntax or selection guidance for the nine 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 verb and resource: parse a Figma file URL, and it adds a distinguishing detail, 'Path discarded,' that separates it from generic URL/shape tools and sibling shape checkers. The scope 'Figma file URL' makes the intended target unmistakable.

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 about when to use this tool versus alternatives such as normalize-url, browser-url-ok, or other shape checkers. 'Path discarded' is a behavioral hint, not a usage condition or exclusion.

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 explicitly says 'No disk access,' which signals a non-destructive, side-effect-free check. However, it does not state what counts as safe, whether it returns a boolean, or how invalid inputs are handled.

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

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

The description is two short sentences with no filler, and the 'No disk access' statement is high-value context. It is appropriately minimal for a simple predicate, though slightly under-specified for a tool with no title.

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 predicate, the description is borderline sufficient, but there is no output schema and no explanation of return value or safety criteria. More importantly, the input schema contains eight unrelated optional parameters and no required parameters, and the description does not say that only 'path' should be used. This leaves room for incorrect 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 parameter descriptions already exist. The tool description adds little beyond naming 'path' as the focus. It also does not clarify that the many other optional properties in the schema, such as url, city, and zone, appear irrelevant to this tool, 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 ('Check whether a path looks safe') and adds a meaningful scope constraint ('No disk access'). It is not a tautology and the core purpose is understandable, though 'safe' is not defined precisely.

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 sibling checkers such as browser-url-ok, domain-shape, or wiki-title-ok. No explicit alternatives, prerequisites, or exclusion conditions are provided.

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

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

With no annotations, the description must disclose behavioral traits on its own, but it only states that coordinates are provided via Open-Meteo. It does not mention that the tool likely makes an external API call, which parameter is required, what happens with multiple parameters, or what the return format is.

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 phrase with no filler and front-loads the core capability. However, it is so terse that it leaves out essential usage and parameter context for a tool with a large input 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?

This is a 9-parameter tool with no required parameters, no annotations, and no output schema, yet the description only provides a one-line capability statement. It does not explain which parameter to supply, what the response looks like, or how the tool behaves when multiple parameters are 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 description adds the provider and output type but does not clarify that 'city' is the intended place parameter among the nine optional fields, nor does it resolve confusion from the schema's unrelated 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 identifies the tool's output as latitude and longitude for a place, using Open-Meteo, which is a clear and specific capability. It broadly distinguishes this from sibling tools like weather-hint and timezone, though it does not explicitly name the expected input (e.g., city).

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 like weather-hint or timezone. The purpose implies use for geocoding, but there is no explicit when-to-use, when-not-to-use, 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 disclosure burden. It states the core behavior (parsing a GitHub URL into owner and repo), but it does not explain what happens with invalid URLs, what the return shape is, or that the many other accepted parameters are effectively ignored for this operation.

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

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

A single front-loaded sentence with no filler. The verb and object appear immediately, and every word contributes to the 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?

There is no output schema and no annotations, so the description must explain what the tool returns and how it behaves on edge cases; it does neither. The schema also lists nine unrelated optional parameters (weather, timezone, JSON, query, etc.), and the description does not clarify why those exist or confirm that only 'url' is used, leaving an agent uncertain about 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 schema already documents all nine parameters and their discard semantics. The description adds no new parameter-level detail, but it does identify the meaningful input domain (GitHub URL), which is enough for the baseline score.

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

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

The description states a specific verb ('parse') and a concrete resource ('owner and repo from a GitHub URL'), making the tool's function immediately clear. It also differentiates it from sibling shape tools such as figma-url-shape and jira-key-shape without needing to inspect the schema.

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

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

The intended use is implied by 'GitHub URL' — an agent will know to reach for this tool when it needs owner/repo from a GitHub URL. However, it does not explicitly name alternatives or state when not to use it, so the routing guidance is left to inference.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that titles are discarded, so only the count is produced. It does not mention return format, network behavior, or failure cases, but for this simple counter the disclosure is adequate.

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 the 'Titles discarded' limitation earns its place by preventing a likely misinterpretation.

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

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

The core function is clear, but the tool accepts nine unrelated optional parameters and the description never states that they can be omitted or that the output is simply a count. The schema compensates for parameter semantics, so the description is adequate but not fully 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?

All nine parameters already have individual descriptions in the schema, so the 100% coverage baseline applies. The tool description itself adds no parameter-level meaning, but it does not need to because the schema already documents each parameter and its discard behavior.

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

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

The description states a precise action and resource: 'Count current Hacker News front-page stories.' Adding 'Titles discarded' clarifies the result is a count, not a list of titles, and distinguishes the tool from generic fetch or web sibling tools.

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

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

The intended use is implied: use this tool when you need the number of current Hacker News front-page stories. However, it names no alternatives, gives no exclusions, and does not say when not to use it.

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

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

No annotations are provided, so the description must fully disclose behavior, but it only identifies a set of names. It does not mention that the many schema parameters appear unrelated or discarded, whether the result is a static list, or what side effects might occur.

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 compact phrase with no filler and leads with the core resource. It is appropriately brief, though it is so terse that it sacrifices explicitness about the tool's behavior.

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

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

With no output schema, no annotations, and nine optional parameters that appear unrelated to timezone names, this one-sentence description is insufficient for an agent to know how to invoke the tool or what response to expect. The agent is left to guess whether zero arguments are appropriate and what the return value looks like.

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

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

Schema description coverage is 100%, so the baseline is 3; every parameter has an individual explanation. The tool description adds no parameter-level meaning and does not help an agent decide which, if any, parameter should be supplied for a timezone-name 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 names the resource (common IANA timezone names) and the intended use (clock calls), so an agent can roughly infer that it returns a list. However, it lacks an action verb and does not explicitly state whether the tool lists, validates, or converts zones, leaving the operation somewhat 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?

There is no guidance on when to use iana-zones versus sibling tools like timezone or utc-time. The phrase 'for clock calls' implies a context but gives no actionable selection criteria, exclusions, or alternatives.

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

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

With no annotations, the description carries the burden. It discloses a public network fetch and an output limitation ('group counts only'), but does not explain which parameters are used/discarded, failure behavior, or redirect handling. This is minimally transparent but not rich.

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, immediately stating the action and the output restriction. No filler or duplicated schema content.

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

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

For a tool with nine optional parameters, no output schema, and no annotations, the description leaves the invocation contract incomplete. The agent does not know which parameter provides the target URL or what shape 'group counts' takes.

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 nominally 100%, but the parameter descriptions are largely irrelevant to robots.txt (city is a weather hint, json validates JSON, ref is a Git ref). The description does not say whether to supply url, host, or something else, so an agent cannot confidently populate the required input.

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

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

The description states a specific action and resource: fetch a public robots.txt and return group counts only. This clearly distinguishes it from generic web-fetch/fetch-status by limiting the output, but it never names a sibling alternative explicitly.

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 'use this when...' statement or comparison to alternatives. The word 'only' implies the tool is for count-level results instead of full robots.txt content, but that inference is not spelled out.

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

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

There are no annotations, so the description carries the full behavioral burden. It discloses that the key is discarded, which is a useful data-handling trait, but it does not state whether the tool returns a boolean, makes network calls, or has side effects. For a validation tool this leaves important behavior implicit.

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

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

Two short sentences with no filler: the purpose is front-loaded and the 'Key discarded' sentence adds a relevant transparency note. It is concise, though the terseness sacrifices essential 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?

With no output schema and no annotations, the description should explain the expected return value and the Jira key format, but it does neither. It also fails to reconcile the tool's Jira-only purpose with a nine-parameter schema full of unrelated fields, leaving an agent unable to reliably construct a correct invocation.

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

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

Schema description coverage is 100%, so the baseline is 3; each parameter already has a description and many state that values are discarded. The tool-level description adds no mapping between the Jira key and any of the nine parameters, and the schema contains many seemingly unrelated parameters, so it does not help an agent select the correct argument.

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: 'Check a Jira issue key shape,' which distinguishes it from sibling shape tools like github-repo-shape or figma-url-shape. However, it does not define what a valid shape is (e.g., PROJECT-123) or identify which input parameter carries 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?

The description implies usage whenever an agent needs to validate a Jira issue key, but it gives no explicit when-to-use/when-not-to-use guidance and does not name alternatives. With a long sibling list of other shape-check tools, this is only minimally sufficient.

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 only that the body is discarded and that an HTTP status is relevant, but it does not explain the output format, network behavior, error handling, or what happens when non-URL inputs like json, city, or zone are provided. This is under-disclosed 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 concise and front-loaded, with the core result stated first and the body-discard behavior added in a second short sentence. However, the brevity is disproportionate to the tool's actual complexity: nine optional parameters and a broad sibling group require more than a two-sentence description. It is compact but incomplete.

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

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

Given no output schema, no annotations, nine optional parameters, and many related sibling tools, this description is far from complete. It offers only a partial return-value hint (HTTP status) and no explanation of how to choose among the parameters or what the tool does for inputs like ref, feed, json, zone, or query. The rich schema descriptions compensate somewhat, but the tool-level context is missing.

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

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

The schema itself provides 100% parameter coverage, so the baseline is 3, but the description does not add useful parameter-level context. It fails to connect the 'HTTP status for a public library docs URL' behavior to the url parameter and gives no hint that the other eight parameters are unrelated to that behavior. The stated purpose even conflicts with the url parameter's own description ('HTTPS URL to normalize or cite'), creating ambiguity rather than clarity.

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 (return HTTP status) and resource (a public library docs URL), so it is not a tautology. However, it only describes one narrow use case while the schema exposes nine heterogeneous optional inputs, and it does not distinguish this tool from siblings like fetch-status or web-fetch. The mismatch between the stated purpose and the parameter list makes the overall purpose genuinely unclear.

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

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

There is no guidance on when to use this tool versus alternatives such as fetch-status, browser-url-ok, normalize-url, validate-json, or timezone. The description also does not say which parameter should be supplied for the documented HTTP-status behavior, even though all nine parameters are optional. The agent is left to guess the intended invocation pattern.

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 disclose behavioral details. It only says 'Values discarded,' which is minimal. It does not state whether keys are counted recursively, what happens with 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?

The description is two short sentences with no filler. The core action is front-loaded in 'Count keys in a JSON object,' and the second sentence adds a clarifying detail. This is appropriately 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?

The tool has nine parameters, no annotations, and no output schema, yet the description does not explain which parameter carries the JSON object, what counts as a 'key,' or how the result is returned. This is insufficient for reliable invocation.

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

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

Schema coverage is 100%, so each parameter already has a description. The tool-level description does not elaborate on parameter syntax or selection, but it does add meaning by indicating that the JSON input is used for counting keys rather than validation, which is the schema's stated purpose.

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

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

The description states a specific action and resource: 'Count keys in a JSON object.' This is clear and distinguishes the tool from vague alternatives. However, it does not mention sibling tools or explicitly connect the action to the `json` parameter, 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?

No usage guidance is provided. The description does not say when to prefer this tool over sibling tools such as validate-json or other shape-check utilities, nor does it indicate which of the nine schema parameters 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?

With no annotations, the description carries the behavioral burden. It does disclose a concrete behavioral trait: query and fragment are dropped. However, it does not clarify behavior for invalid URLs, whether any network access occurs, or how ignored input parameters are handled; the schema partially covers the latter.

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

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

Two short sentences with no filler. The core behavior is front-loaded ('Return origin, host, and path') and the additional drop behavior is stated economically.

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 output schema, and no annotations, the description is somewhat under-specified: it does not state the return shape, does not explicitly identify `url` as the only meaningful input, and gives no error or edge-case behavior. The schema compensates for param discard notes, but the description alone leaves notable gaps.

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 and even creates slight ambiguity by using 'path' as an output term while a 'path' input parameter exists. The schema's individual 'discarded' notes are what actually clarify parameter roles.

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 ('Return') and names the resource ('origin, host, and path for a URL'). It also states that query and fragment are dropped, which clearly distinguishes this extraction/normalization tool from sibling URL-validation tools such as browser-url-ok or playwright-url-ok.

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

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

The description implies usage: use this tool when you need the origin, host, and path of a URL. However, it gives no explicit when-to-use or when-not-to-use guidance and does not mention any sibling alternatives, leaving selection largely to inference.

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

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

With no annotations, the description carries the full transparency burden. It discloses one trait (no browser launch) but does not say whether a network request is made, what response shape to expect, or how the optional inputs are treated. The schema descriptions mention that many values are discarded, but the tool description itself does not.

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 both contribute: the capability and the no-browser caveat are front-loaded. It is efficient, though slightly under-specified given the breadth of the 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?

With nine optional parameters, no annotations, and no output schema, the description is not complete enough. It fails to explain the return value, which parameter(s) to populate, or what 'opened' means, leaving an agent without enough information to invoke the tool confidently.

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

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

Schema description coverage is 100%, so each parameter is already documented in the schema and the description does not need to restate them. The tool description adds no parameter-level meaning beyond the schema, and it does not clarify which parameter is the primary input for the URL check, so the baseline score 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 names a specific action ('check') and resource ('URL can be opened') and adds a useful caveat that no browser is launched, which helps separate it from browser-url-ok. However, 'can be opened' is ambiguous: it could mean reachability, URL syntax validity, or a Playwright-specific navigation check, and the schema's nine unrelated optional parameters add confusion rather than clarification.

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 usage context is provided. The description never says when to choose this tool over fetch-status, browser-url-ok, web-fetch, or normalize-url, and it gives no conditions or exclusions. 'No browser is launched' implies a lightweight check but does not indicate when that is preferable.

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 that the query is discarded after use, which is a meaningful behavioral note. However, it does not say what happens with the other eight accepted parameters, whether an empty or missing query is valid, or what the tool returns.

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

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

Two short sentences, front-loaded with the main action, and 'Query discarded' earns its place as a data-handling note. It is slightly too terse to be a 5 because it omits a pointer to the actual input field.

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

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

With 9 optional parameters, no annotations, and no output schema, the definition underdetermines correct invocation. It never states that the `query` parameter is the one to populate or what happens to the unrelated parameters, so an agent must infer critical call details from the schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level information; the schema's per-parameter descriptions carry that load. The many unrelated optional fields still create ambiguity about which parameter is the intended '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 a specific operation ('Count characters') on a specific resource ('a search query'), and the name plus note about discarding make it distinct from sibling count/validation tools. It is not a restatement of the name and has a clear outcome.

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

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

There is no guidance about when to use this tool versus alternatives, no prerequisites, and no mention of when not to use it. The only usage signal is the implied purpose of counting query characters.

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

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

With no annotations, the description carries the full burden of explaining behavior, but 'short catalog' only weakly implies a read-only reference. It does not disclose what the tool returns, whether parameters are consumed or ignored, or any side effects.

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

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

The description is a single short phrase with no wasted words, so it is concise. However, it is too thin to serve as an adequate tool definition, especially given the complex input schema and sibling tool 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 description is inadequate for the tool's context: there is no output schema, no annotations, multiple optional inputs, and many sibling tools. It does not explain what the agent should pass in or what it can expect in return, leaving important invocation details 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?

The input schema provides descriptions for all eight parameters, so schema coverage is high. The tool description itself adds no meaning about how parameters relate to the catalog, so it does not improve on the schema, but the schema already carries the baseline semantic 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 identifies the domain—common HTTP status codes—and implies the tool provides a catalog/list of them, but it lacks an explicit verb or operation. It does not clearly distinguish itself from sibling tools like fetch-status, leaving the exact action the agent should expect 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?

There is no guidance on when to use this tool instead of alternatives such as fetch-status or web-fetch. No context, prerequisites, or exclusions are provided, so an agent cannot decide between this and related 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 burden. It does disclose a key behavior: the prompt is discarded rather than influencing the output. However, it does not clarify whether the many optional inputs are accessed, whether the tool is read-only, or what exactly the returned template contains beyond 'three-step.'

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 main action. 'Prompt discarded' is useful but slightly ambiguous because there is no explicit 'prompt' parameter in the schema, which costs a point.

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 zero required parameters that returns a fixed template, the core behavior is mostly covered. Still, the description leaves unclear why nine optional parameters exist and whether any of them can shape the returned template, which an agent would need to choose and call it confidently.

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

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

Schema coverage is 100%, so the baseline is 3; each parameter already has a semantic description in the schema. The tool description adds no additional parameter-level meaning, but full schema coverage makes that acceptable.

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: 'Return a three-step thinking template.' It is not a tautology and clearly distinguishes the tool's output from validation or lookup siblings, though it doesn't explicitly contrast with any sibling.

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

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

There is no guidance about when to use this tool versus alternatives, no mention of context that would make it appropriate, and no exclusions. The note 'Prompt discarded' is behavioral rather than selection 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 must carry the transparency burden. It accurately describes a read-only time lookup and restricts input to IANA names, but it does not disclose invalid-input behavior, output format, or DST handling. This is adequate but not detailed.

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 meaning, making it easy for an agent to parse quickly.

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

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

For a simple read-only lookup, the core in/out behavior is conveyed. However, with no output schema, no annotations, and an input schema containing many unrelated parameters, the description alone does not fully ensure correct invocation; the timezone parameter example helps fill the 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 description echoes the timezone parameter's IANA semantics but adds no format, examples, or invocation guidance beyond what the schema already provides, and the schema also contains many unrelated 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 clearly states what the tool does: returns the current time for a named IANA timezone. It is not a tautology and communicates the core resource and operation, though it does not explicitly differentiate from sibling tools like utc-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 about when to choose this tool over alternatives such as utc-time or iana-zones. The description implies an IANA timezone is needed, but it does not state exclusions, prerequisites, or when-not-to-use conditions.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure. It only says 'Current UTC timestamp' and does not mention how the many input parameters are handled, despite the schema descriptions noting that values 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?

The description is extremely short and front-loaded, but it is under-specified rather than appropriately concise. It essentially restates the tool's name without adding actionable detail about the parameters or behavior.

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

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

For a tool with eight input parameters and no annotations or output schema, this one-phrase description is grossly incomplete. An agent cannot determine which parameters are relevant, how they affect the output, or why they exist.

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

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

The input schema already provides descriptions for all parameters, so schema coverage is high and the baseline is 3. The tool description adds no parameter meaning beyond what the schema already provides.

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

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

The description clearly states that the tool returns the current UTC timestamp, which is an unambiguous resource and output. However, it does not explicitly differentiate itself from the sibling 'timezone' tool beyond the fixed UTC qualifier.

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 alternatives like 'timezone' or 'iana-zones'. There are no when-to-use, when-not-to-use, or exclusion conditions 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?

Discloses that the body is discarded, which is a useful no-retention signal. However, with no annotations present, the description carries the full burden and does not mention return values, error behavior, or effects of the many other 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?

Extremely concise and front-loaded; both sentences contribute meaning. The slight ambiguity in 'body' prevents a perfect 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?

For a tool with seven heterogeneous parameters and no output schema, this description is too terse. It does not explain what response an agent should expect, why many params are accepted, or how the extra fields relate to JSON validation.

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 each parameter, so the description adds little beyond that. It fails to reconcile the tool-level concept of 'body' with the unrelated-looking parameters such as url, city, host, and feed.

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 concrete action: 'Check whether a body is valid JSON.' This is a clear verb-plus-resource definition. It does not explicitly differentiate from sibling validation tools, 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?

No guidance on when to use this tool versus sibling tools like domain-shape or wiki-title-ok. There are no exclusions, prerequisites, or context hints beyond the verb itself.

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 indicates a read-only, external lookup via Open-Meteo, but it does not disclose the output format, failure behavior, API dependency constraints, or what happens with the many other parameters in the schema. The per-parameter 'discarded' notes in the schema help, but the description itself is minimal.

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

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

The description is a single, front-loaded sentence with no unnecessary words. It states the primary function and data source efficiently. This is an example of concise writing that makes the tool's main purpose immediately graspable.

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, but the description only addresses the city parameter. It does not explain the relevance or irrelevance of the other 8 parameters, nor does it describe the return payload or edge cases. This is a significant completeness gap for a tool with such a broad and seemingly multi-purpose schema.

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

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

Schema description coverage is 100%, so the schema already explains every parameter, including 'city'. The description adds little beyond clarifying that the city parameter is the one relevant to the weather lookup. With full schema coverage, a 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 clearly states the tool's core function: retrieving the current temperature for a city via Open-Meteo. While it lacks an explicit verb like 'get' or 'returns', the intent is unmistakable. It does not explicitly mention sibling differentiation, but it is specific enough to distinguish from most other tools in the sibling list, such as geo-hint.

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

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

The description implies usage: when an agent needs the current temperature for a city. However, it provides no explicit guidance on when not to use this tool or which alternative to prefer, especially given the sibling tools like geo-hint. The usage context is implied rather than explicitly stated.

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

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

With no annotations, the description carries the full transparency burden. It usefully discloses that the body is discarded and that the tool returns status/content type, but it does not mention whether the URL is actually fetched, error behavior, rate limits, or any side effects.

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

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

Two short sentences, front-loaded with the core result and a key behavioral caveat. Every word earns its place; there is no redundant or boilerplate content.

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 output schema, no annotations, and several closely related sibling tools. The description does not explain the role of the many non-URL parameters, what the return value looks like, or how to choose this tool over similar siblings, so an agent has limited context for confident invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself adds no parameter-level meaning beyond identifying 'public URL', but the schema already documents each parameter and notes when values are discarded.

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

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

The description clearly states the tool's outcome: HTTP status and content type for a public URL, with a notable detail that the body is discarded. It is concise and understandable, though it does not explicitly differentiate this tool from similar siblings like fetch-status or browser-url-ok.

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

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

There is no guidance about when to use this tool versus the many related siblings such as fetch-status, normalize-url, or browser-url-ok. The phrase 'public URL' implies a use case, 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 present, the description carries the full burden. It adds one behavioral detail: 'Title discarded after the call,' indicating statelessness/privacy. However, it omits the return format, whether a network request occurs, and error behavior, leaving only minimal 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 two short sentences with the core purpose front-loaded. The second sentence adds a useful behavioral note, though it is redundant with the title parameter's schema description. It is appropriately concise, though not maximally 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 complex, unfocused schema and the absence of annotations or output schema, the description is insufficient for reliable invocation. It fails to indicate which parameter to provide, what the tool returns, or how it behaves on failure, so an agent could easily select the wrong input among many listed.

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 lists eight heterogeneous parameters (ref, url, city, feed, host, json, path, title), most with descriptions that reference unrelated tools (e.g., 'City name for a public weather hint'). The description does not clarify that only the 'title' parameter is relevant; it merely repeats the discard note already in the schema, making parameter selection 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 opens with a direct, specific statement: 'Check whether a Wikipedia title exists.' This clearly identifies the verb, resource, and scope, and distinguishes it from sibling shape-check tools like file-path-ok or normalize-url by naming Wikipedia explicitly.

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

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

No explicit when-to-use or alternative exclusions are provided. The intended use is implied by the purpose statement—use when needing to verify a Wikipedia title—but nothing names sibling alternatives or warns against misuse for other shape checks.

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