ISO country ES

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 non-obvious behavior: task text is discarded, and the tool returns CLI setup, how-it-works, skill file, and remote MCP hops. It does not state whether the call is read-only, incurs cost, or requires authentication, so transparency is partial.

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

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

Two sentences with no filler: purpose is front-loaded, outputs are listed, and the important 'task text discarded' caveat is included. Every clause earns its place, and the structure is easy to scan.

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

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

Despite having 9 optional parameters and no output schema, the description never explains what input an agent should provide, how the parameters relate to the gateway lookup, or what 'remote MCP hops' means in practice. An agent would still be guessing about invocation after reading it.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description itself adds no parameter-level meaning, but the input schema already documents each of the nine parameters. The description neither compensates for nor worsens parameter understanding.

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 specific action and resource: 'Find a public pay-per-call tool gateway (Monid),' and the second enumerates returned artifacts. This differentiates it from most siblings, though 'Monid' is not defined and no explicit contrast with sibling tools is given.

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 the many sibling utilities. 'Task text discarded' is a caution about behavior, not a selection criterion, and no alternative tools are named or excluded.

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 does disclose one meaningful behavioral trait beyond the name: no browser is launched. However, with no annotations at all, the description carries a heavier burden and still does not say whether the tool performs a network request, only validates syntax, or what it does with the various discarded 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 only two short sentences, front-loads the core action, and contains no filler. Every word contributes to the tool's basic purpose.

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

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

For a tool with nine parameters, no output schema, and no annotations, this description is too thin. It does not indicate which parameter should be used for the stated URL check, what the return value looks like, whether a failed check means invalid syntax or unreachable host, or how it differs from nearby URL-related siblings.

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

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

Schema description coverage is 100%, so all nine parameters already have descriptions and the baseline is 3. The tool description itself adds no parameter-level meaning and does not reconcile its URL-focused purpose with the many unrelated accepted 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 names the action ('Check whether a URL can be opened') and the resource ('a URL'), and adds a distinguishing caveat: 'No browser is launched.' However, the nature of the check is still ambiguous relative to siblings like normalize-url, fetch-status, and playwright-url-ok, and the schema's nine mostly unrelated parameters muddy the apparent focus.

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. The statement 'No browser is launched' hints that it is lighter-weight than a browser-based check, but it does not name alternatives or provide 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 full behavioral disclosure burden. It adds one behavioral note, 'Expression discarded,' but omits return behavior, side effects, error handling, and what the caller should expect. This is insufficient for a tool with no structured safety hints.

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-loads the main action, but the second sentence, 'Expression discarded,' is ambiguous and does not clearly earn its place. It is concise but sacrifices essential 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?

The tool has 9 parameters, no annotations, and no output schema, yet the description provides no parameter mapping, return behavior, or example. An agent cannot reliably select inputs or interpret the result from this definition.

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

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

Although the schema has 100% parameter coverage, the description references an 'expression' that does not map to any of the nine schema parameters such as ref, url, json, or query. The agent cannot determine which parameter should contain the arithmetic expression or how these parameters relate to the described operation.

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

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

The description clearly states the core action: 'Evaluate a+b style arithmetic.' This is a specific verb and resource, and it distinguishes the tool from sibling shape/URL/file validators. However, it does not explain how the expression is supplied, which prevents a higher score.

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 state when to use this tool versus any alternative, nor does it give conditions or exclusions. Only an implied use case of arithmetic evaluation exists.

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

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

With no annotations, the description carries the burden of behavior disclosure but only says the record is 'Public'. It does not state whether the call is read-only, what response format to expect, or how parameters affect the result. The parameter descriptions mention discarded values, but the main description 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 short and free of filler, but it is under-specified rather than usefully concise. For a tool with nine optional parameters and no output schema, a single noun phrase is insufficient structure, and no key information is front-loaded because there is so little 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 definition does not explain what the record contains, what the return value looks like, why the parameters exist, or when this tool should be selected. Given the nine-parameter schema and the absence of an output schema, this is incomplete for an agent trying to call 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 parameters are already documented at the schema level, establishing a baseline of 3. The main description adds no parameter meaning beyond the schema. The schema's per-parameter notes compensate for the prose silence.

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 resource as a public ISO 3166-1 record for Spain, which distinguishes it from validator-style siblings. However, it uses the noun 'record' with no verb, so it does not state an operation such as retrieving, returning, or citing the record. This is a clear subject but a vague action.

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 rather than a sibling. It does not name alternatives, prerequisites, or conditions, even though the sibling list suggests many similar lookup/validation tools. An agent is left to infer usage from the name alone.

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

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

There are no annotations, so the description carries the behavioral transparency burden. It does disclose a meaningful trait ('Page content is not stored'), but it does not explain whether a network request is made, how the auxiliary parameters are handled, whether auth or rate limits apply, or what the exact response shape 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 two short, front-loaded sentences with no redundancy. It states the core behavior first and then adds a useful privacy-related caveat.

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 names the return fields and the no-storage behavior, which is useful. However, with nine optional parameters, no annotations, and no output schema, an agent still lacks a full picture of how to structure a valid call and interpret the result beyond the three named fields.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds little parameter-specific meaning beyond identifying 'url' as the central input and does not clarify how the other eight parameters relate to the stated output.

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: it returns host, scheme, and HTTP status for a URL. This is a specific verb-resource combination, but it does not differentiate this tool from closely related siblings like fetch-status, normalize-url, 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?

No usage context is provided. The description does not mention when to choose citation over the many URL-related sibling tools, nor does it note any 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?

The description adds a meaningful behavioral detail beyond the schema: 'No identifiers are retained'. This privacy disclosure is helpful, and the parameter descriptions echo discard semantics. However, with no annotations, the description carries the full burden, and it does not disclose whether the tool performs network calls, has side effects, or what the classification output actually 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 extremely concise and front-loaded: 'Show how this request is classified' is the first sentence. There is no filler. The brevity does sacrifice useful context, but as written, every clause 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 9 optional parameters, no required fields, no output schema, and no explanation of what the classification result looks like, the description is under-specified. The sibling tool list hints at a routing purpose, but the description never states how to populate the parameters, what the tool returns, or how the result should be used.

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 each parameter already has a concrete description such as 'Git ref name; discarded after the shape check' or 'JSON text to validate; discarded after the check'. The tool description adds no additional parameter-level meaning, so the baseline score 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 uses a specific verb ('Show') and a target ('how this request is classified'), so it is not a pure tautology. However, it never explains what 'compatibility' or 'classification' means, and it does not distinguish this tool from the many sibling lookup/check tools. An agent gets the gist but not the actual classification semantics.

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. It does not mention routing to sibling tools, what input should be populated, or when it should be avoided. With 27 sibling tools, the absence of any usage context leaves the agent without clear 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 full behavioral disclosure burden. It states the core operation and an important exclusion, but does not disclose return format, network behavior, side effects, or which input is actually consumed. This is adequate for a simple pure function but leaves gaps.

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

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

A single front-loaded sentence with no filler. The negative scope is concise and meaningful, and every word contributes to the tool's selection and invocation.

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, a one-sentence description is under-specified. It does not explain the return shape, whether unused parameters are ignored, or how to resolve the mismatch between the narrow 'hostname' purpose and the broad optional 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 coverage is 100%, so the baseline is 3. The description adds hostname-label context, but it does not clarify that 'host' is the relevant parameter among 9 optional fields, nor what the other parameters mean for this tool. It does not materially exceed 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 names the exact operation ('Split'), the target ('a hostname'), and the output ('labels'), and adds a clear negative scope ('without WHOIS or ownership data'). This distinguishes it from sibling shape/lookup tools that operate on URLs, files, repos, or ownership data.

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 clearly scopes use to hostname label splitting and tells the agent what the tool will not provide (WHOIS/ownership). It does not explicitly name sibling alternatives or provide when-not conditions, so it stops short of 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?

With no annotations, the description must carry the behavioral burden. It discloses the HTTP method (HEAD, no body), the access context (public URL), and the output scope (status only). It does not specify the exact status format or edge-case behavior, but it is honest and useful for a simple read-only check.

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 message: operation, target, and output scope.

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 enough to invoke the tool with a url and understand that the result is a status. However, with 9 optional parameters, no output schema, and no annotations, an agent may be unsure what 'status' precisely means and whether any non-url parameters affect the result.

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 of the 9 optional parameters. The description adds little beyond indicating that a URL is the relevant input, which is already present in the url parameter 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 clearly identifies a specific operation: HEAD a public URL and return status only, with the verb and resource stated precisely. It does not explicitly differentiate from siblings like web-fetch or browser-url-ok, so it is not a 5.

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

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

The description implies the intended use case: checking a public URL's status without retrieving content. However, it provides no explicit when-to-use versus alternatives guidance, such as using web-fetch when content is needed.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It only says 'Path discarded,' which is unclear—it could refer to a parameter or to the URL path—and it does not state whether network access occurs, what side effects exist, or what the return behavior 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 very short and front-loaded with the core purpose. 'Path discarded' is cryptic, but the overall structure is efficient without redundant filler.

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

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

With no output schema, no annotations, nine parameters, and numerous sibling URL tools, this two-sentence description is not sufficient for an agent to confidently invoke the tool. It does not explain the return value, which parameters matter, or what 'shape' checking entails.

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 does not clarify that `url` is the Figma URL to parse or explain why many unrelated parameters are present in the schema.

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

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

The description states a specific action ('Parse') and a specific resource ('a Figma file URL'), which clearly differentiates this tool from the sibling URL tools like browser-url-ok or normalize-url. However, 'Path discarded' is ambiguous and the description does not specify what a successful parse yields.

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 this tool is for Figma file URLs, but it does not mention when to prefer it over the many related sibling tools, nor does it give any exclusions or alternative routing. Usage context is therefore only implicit.

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

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

With no annotations, the description carries the burden of behavior disclosure. It does add a meaningful trait: no disk access, making this a non-side-effecting syntactic check. But it does not describe what 'safe' means, what the return value looks like, or how invalid paths are reported.

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

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

The description is two short sentences with the purpose first and the key constraint second. There is no filler, repetition, or unnecessary detail.

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

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

The core action and a critical non-effect are stated, which is adequate for a simple tool. However, the definition lacks an explicit return-value contract, a definition of 'safe', and any routing guidance among sibling tools. The unusually broad schema with many optional parameters also goes unaddressed.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level detail, though the schema already documents 'path' as the file path to check. The presence of eight unrelated optional parameters is confusing, and the description does not clarify that only 'path' is 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 ('a path') and the action ('Check whether ... looks safe'), and the 'No disk access' note distinguishes it from filesystem-touching tools. However, 'looks safe' is vague about what safety criteria are applied, so the agent only gets a general sense of the check.

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

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

There is no explicit guidance on when to use this tool versus sibling shape-check tools such as browser-url-ok, domain-shape, or wiki-title-ok. 'No disk access' implies it is not for real filesystem checks, but no alternative is named and no usage 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?

No annotations are present, so the description carries the full burden. It reveals that Open-Meteo is the data source, suggesting an external network call, but it does not mention output format, error behavior, rate limits, or whether the lookup is read-only.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to the core meaning, making it efficient 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?

The tool has no annotations, no output schema, and a nine-parameter schema with no required fields. The description does not state which parameter to provide or what the response structure will be, leaving substantial ambiguity 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 description coverage is 100%, so the baseline is 3. The tool description does not add parameter-level detail, and the schema contains nine heterogeneous fields with no indication which one geo-hint actually uses, leaving the agent to infer that 'city' is likely the intended 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 clear result: latitude and longitude for a place, using Open-Meteo. It is specific enough to distinguish from generic validation or fetch tools, though it does not explicitly name the input form (e.g., city name).

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

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

No guidance is given on when to use this tool versus alternatives like weather-hint or timezone. The description implies a place-to-coordinates lookup but provides no exclusions, prerequisites, or sibling-tool 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?

Annotations are absent, so the description must explain behavior; 'parse' conveys a non-mutating operation but nothing about validation failures, what happens for non-GitHub URLs, or what result is returned. The schema's 'discarded after the shape check' hints at validation semantics, but the description itself does not commit to them.

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

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

One short sentence front-loads the purpose with no wasted words. It is exactly as concise as the simple function warrants.

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, an agent still cannot tell what the tool returns or how to treat invalid or foreign URLs, and the irrelevant parameters create confusion. The description is not sufficient for a reliable call on a nine-parameter 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?

The description adds one useful semantic link—the relevant input is a GitHub URL and the output is owner/repo—beyond the generic 'HTTPS URL to normalize or cite' schema text. However, with nine properties, no required parameters, and additionalProperties false, it does not clarify which of the many unrelated fields should be supplied or how they relate.

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), which clearly distinguishes this tool from sibling URL-shape tools for Figma, JIRA, or domains. It lacks only an explicit statement of the output form, so it is not a perfect 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 guidance is given for when to choose this tool over alternatives such as normalize-url, domain-shape, or figma-url-shape. The phrase 'from a GitHub URL' implies a GitHub-URL use case, but there are no exclusions, fallback directions, or examples.

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 behavioral disclosure, but it only says titles are discarded. It does not mention whether the tool fetches live data, whether it is read-only, whether it returns a number vs text, or how the many optional parameters are treated.

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, no filler, and the core purpose is front-loaded. 'Titles discarded' is a useful qualifier that earns its place.

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

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

The tool is simple, but there is no output schema and no annotations, so the description should state the return value and clarify the role of the nine optional parameters. It does neither, leaving an agent 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 baseline is 3. The description adds little beyond the schema, and 'Titles discarded' largely repeats the feed parameter's description rather than clarifying which of the nine parameters matter or that all are optional.

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

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

States a specific action ('Count'), a specific resource ('current Hacker News front-page stories'), and an explicit boundary ('Titles discarded'). This is immediately distinguishable from sibling tools like web-fetch or status-catalog 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?

No guidance on when to use this tool over siblings, no exclusions, and no mention that the tool likely needs no arguments or how to invoke it. The phrase 'Titles discarded' provides a scope hint, but not a usage context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state what the tool returns, whether it validates or lists data, whether input parameters are used or ignored, or any side effects. The description essentially only restates the tool's subject matter.

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

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

The description is a single concise phrase with no filler or redundant elaboration. The key concept is front-loaded, though the lack of a verb makes it less of a complete instruction.

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 for a tool with no output schema and nine optional parameters. It does not explain the return format, whether parameters are relevant or discarded, or how output relates to clock calls. An agent would likely need to call or inspect the tool to understand expected 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%, and each parameter already has its own description, so the high-coverage baseline applies. The tool description adds no parameter meaning, but the schema itself is sufficient for individual parameters; however, the parameters appear unrelated to IANA timezone names, which is not addressed.

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 resource (IANA timezone names) and intended context (clock calls), but it lacks a verb such as 'returns' or 'lists', and it does not clearly separate this from sibling tools like timezone or utc-time. It is more of a noun phrase than a functional description.

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

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

The phrase 'for clock calls' gives a weak usage context, but there is no explicit guidance on when to prefer this tool over alternatives, no mention of excluded cases, and no stated relationship to sibling clock-related tools. An agent must infer the intended use.

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 reveals the fetching behavior and the 'counts only' return style, but it does not explain what happens when robots.txt is missing, which input selects the target, whether the call requires network access, or any failure 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 one short, front-loaded sentence with no filler. It communicates the core action and the constrained return value efficiently.

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

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

For a tool with 9 optional parameters and no output schema or annotations, this description is too thin. It omits how to invoke it correctly, which parameter is the target, how it relates to sibling fetch/shape tools, and what the output structure for 'group counts' 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 each parameter already has a textual description. However, the tool description itself does not clarify which parameter should be used to specify the robots.txt URL or host; the schema lists many seemingly unrelated optional parameters, so the description adds little semantic value beyond the schema.

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

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

The description states a specific action and resource: 'Fetch a public robots.txt'. It also narrows the output to 'group counts only', which clearly distinguishes this from generic fetch tools like web-fetch or fetch-status that might return full content or status.

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 siblings such as web-fetch, fetch-status, or domain-shape. There are no stated conditions, alternatives, or exclusions, so an agent must guess based on the name and one-line 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?

The phrase 'Key discarded' is a useful data-handling disclosure beyond the absent annotations, indicating the key is not retained. However, it does not disclose what the tool returns, whether an invalid shape raises an error, or any other side effects.

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

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

Two short sentences with the purpose front-loaded and no filler. Loses a point because 'Key discarded' is ambiguous without a named key parameter, but the text is appropriately compact.

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

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

For a 9-parameter tool with no output schema and no annotations, this description is too thin: it omits return behavior, the expected key format, and which parameter carries the key. The mismatch between the stated purpose and the schema makes the tool hard to invoke correctly.

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

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

Although schema description coverage is 100%, the description introduces a 'Jira issue key' concept that none of the nine schema properties references; there is no key or jira parameter. An agent cannot tell whether to pass the key as ref, query, or some other property.

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

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

States a specific action (check) and a specific resource (Jira issue key shape), distinguishing it from sibling shape validators like github-repo-shape or domain-shape. It is not a tautology, though it does not define what a valid Jira key 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?

No guidance on when to use this tool versus alternatives, and no exclusions or prerequisites. The only usage signal is the tool name and the verb phrase, which is implied 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 disclosure burden. It usefully reveals that only the HTTP status is returned and the response body is discarded, but it does not cover redirects, error behavior, network side effects, or any prerequisites for the URL.

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, main purpose front-loaded and the behavioral qualifier ('Body discarded') earns its place. There is no redundant 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 core output is stated and the schema is fully described, making this minimally viable. However, with no annotations, no output schema, nine optional parameters, and many sibling URL/status tools, the definition lacks the context needed to pick this tool unambiguously over alternatives.

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

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

The input schema covers all 9 parameters with descriptions, so the baseline is 3. The tool description adds no parameter-level detail beyond pointing at a URL, and it does not clarify whether the other eight optional fields are meaningful for this tool.

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

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

The description states a concrete action ('HTTP status') and a resource type ('public library docs URL'), and adds that the body is discarded. This tells an agent what the tool returns, but the phrase 'public library docs' is ambiguous and the description does not distinguish it from sibling status tools such as 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?

No when-to-use guidance, exclusions, or alternatives are given. With several overlapping sibling tools, the agent must infer usage from the name and terse description, so the guidance is effectively absent.

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 does disclose an important behavioral trait, 'Values discarded,' implying a pure read/compute operation with no storage of values. It does not state behavior on invalid JSON, whether keys are top-level or recursive, or what the output 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 two short, front-loaded sentences with no filler. Both sentences add value: the purpose and the fact that values are discarded.

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 and no output schema, yet the description does not say which parameter contains the JSON object, what the return value is, or whether the many discarded parameters are meant to be ignored. The schema descriptions also seem mismatched, especially the json field describing validation rather than counting, leaving the agent without enough context 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?

Input schema coverage is 100%, so the schema already documents all parameters. The description adds almost no parameter-level meaning beyond the schema and does not explicitly identify the json parameter as the one to populate. Baseline 3 is appropriate because the schema handles parameter documentation.

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

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

The description clearly states a specific verb and resource: count keys in a JSON object. It also communicates a key differentiator, that values are discarded, which sets it apart from validation or transformation tools. It is not a 5 because it does not explicitly distinguish it from sibling validate-json and leaves ambiguity about whether nested keys are counted.

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 usage is implied: use this when you need the number of keys in a JSON object rather than validation, fetching, or normalization. However, there is no explicit when-to-use or when-not-to-use guidance, and no alternative sibling tool is 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?

It does disclose a real behavioral trait: query and fragment are dropped. However, with no annotations, the description does not mention accepted URL scheme, output format, error behavior, or how the many unrelated schema parameters are handled, leaving significant behavioral gaps.

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

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

Two short sentences with no filler. The core output and the key transformation are front-loaded, making the description easy 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 tool with 9 parameters, no annotations, and no output schema, this description is too thin. It does not explain why parameters like city, json, feed, or zone exist, which are ignored, or what the return value looks like, so an agent cannot fully understand the tool's actual contract.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description adds little parameter-specific meaning. The description's 'query' wording is slightly ambiguous against the schema's 'Search text; discarded after the length check' description, but it does not actively mislead enough to lower the 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 operation ('Return origin, host, and path') on a clear resource ('a URL') and adds a concrete normalization behavior (query and fragment are dropped). This clearly distinguishes it from sibling URL checkers like browser-url-ok or fetchers like web-fetch, even without naming them.

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

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

The description gives no guidance on when to use this tool versus alternatives, and it does not mention exclusions or prerequisites. An agent must infer the use case from the name and behavior alone.

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

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

With no annotations, the description carries the full burden. It usefully discloses that no browser is launched, which is non-obvious given the playwright name. However, it does not say whether a network request is made, whether the check is purely syntactic, what side effects occur, or what the result 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?

Two short sentences with no filler. The core action is front-loaded, and the critical 'No browser is launched' caveat is included immediately without redundant wording.

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

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

The tool has 9 parameters, no output schema, and no annotations, so the description must explain far more than it does. It fails to define what 'can be opened' means, what the returned value indicates, when to use this over siblings, and how the many optional parameters interact with the check.

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 little parameter meaning beyond identifying 'url' as the central resource and implying the other parameters are secondary or 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 clear verb and resource: 'Check whether a URL can be opened.' The added 'No browser is launched' helps distinguish it from browser-url-ok, but 'can be opened' is still somewhat generic and could imply either reachability, syntax validity, or HTTP success.

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 no-browser statement implies a contrast with browser-url-ok, but the description never explicitly says when to use this tool versus alternatives like fetch-status, normalize-url, or browser-url-ok. Usage context is only implied, not stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Query discarded' is a useful note about non-persistence, but it does not clarify what the tool actually returns, whether it has side effects, or that eight of the nine schema parameters are effectively ignored. The schema descriptions hint at 'discarded after the shape check' for other fields, but the tool description itself omits this and the overall behavior is opaque.

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

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

The description is two short sentences with no filler. The primary action is front-loaded ('Count characters in a search query'), and the second sentence adds a behavioral note. It is appropriately concise, though the second sentence could arguably be integrated or expanded slightly with the output expectation.

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, and no annotations, making it moderately complex. The description is far too minimal to be complete: it does not tell the agent which parameter to use, what the return value looks like, whether the other parameters are accepted but ignored, or provide any context for why the schema includes unrelated fields like url, city, feed, etc. An agent would likely be confused when trying to invoke this tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds the concept of counting characters in a search query, which aligns with the 'query' parameter's schema description ('Search text; discarded after the length check'). However, it does not explain the relationship between the stated purpose and the other eight parameters (ref, url, city, feed, host, json, path, zone), leaving their presence confusing.

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 characters in a search query.' This makes the core purpose clear and distinguishes it from sibling tools like memory-key-count (which likely counts keys) and hn-front-count. However, it doesn't explicitly state the output (e.g., returns the character count) or differentiate from a generic string-length 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?

Usage is implied by the description: if an agent needs to know the length of a search query, this tool would be appropriate. But there is no explicit guidance about when to use this versus alternatives, no mention of prerequisites, and no exclusions. The context signals show many sibling tools, but the description does not help an agent decide between 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 present, so the description carries the full burden of behavioral disclosure. It suggests a read-only reference catalog but says nothing about side effects, return values, or how inputs affect the output. The schema's 'discarded' notes hint at no-op inputs, but the description itself does not disclose this 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 short sentence with no fluff, but it is under-specified rather than economically complete. It earns a middling score because it is concise yet omits critical operational detail.

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

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

For a tool with no annotations, no output schema, seven parameters, and sibling tools with overlapping HTTP-related functions, this description is not close to sufficient. An agent cannot determine what input to provide, what output to expect, or when this catalog is the right choice.

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

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

All seven parameters have schema descriptions, which sets the baseline at 3. However, the parameter descriptions describe generic discard/normalize/validate semantics that are not tied to an HTTP status catalog and no parameter identifies a status code to look up; the tool description adds no additional 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 description identifies the resource as a short catalog of common HTTP status codes, so an agent can grasp the domain and approximate function. However, it is a noun phrase with no action verb, and it does not specify how to query the catalog or distinguish it from fetch-status or compatibility. It is clearer than a pure tautology but still vague about what the tool actually returns or 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?

There is no guidance about when to use this tool rather than sibling tools such as fetch-status, compatibility, or domain-shape. The description merely states what the catalog contains and leaves all selection context implicit. No exclusions or alternative 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 carry the full transparency burden. It discloses one behavioral trait: 'Prompt discarded' signals that input is not used, which is useful. But it does not state return format, side effects, or what 'thinking template' entails, so transparency is limited.

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

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

The description is two short sentences with no wasted words. 'Prompt discarded' is a meaningful behavioral note and the main action is front-loaded. It is concise, though perhaps too sparse to be fully helpful.

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 severely incomplete. It does not explain what the three-step template looks like, how to use the returned value, whether any parameters should be passed, or what 'prompt' refers to. An agent cannot confidently invoke this tool correctly.

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

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

Schema coverage is 100% and each parameter has a description, so the baseline is 3. However, the tool description's 'Prompt discarded' conflicts with schema descriptions that say parameters are checked then discarded, and there is no 'prompt' parameter. This creates ambiguity about whether parameters matter, lowering the 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 action: 'Return a three-step thinking template.' This gives a clear verb and resource, and the name 'think-steps' corroborates the intent. However, it does not clarify why an agent would use this over sibling tools or what the template contains, leaving purpose partially 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 this tool vs alternatives. The description does not mention any conditions, exclusions, or relationships to sibling tools, so an agent has no basis for selecting it appropriately.

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 states the core function and does not disclose output format, edge cases, whether the IANA name is validated, or what happens on invalid input. It also fails to explain the many 'discarded' parameters in the schema.

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

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

The description is a single, front-loaded sentence with no wasted words. It states the essential purpose immediately, though brevity comes at the cost of operational detail.

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

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

The tool has 9 optional parameters, no output schema, no annotations, and a schema that does not obviously include a timezone parameter. The description does not explain what input to provide, what output to expect, or how this relates to sibling tools. An agent would struggle to invoke it correctly.

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

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

Schema coverage is high, so the baseline is 3, but the description does not map the 'named IANA timezone' to any parameter. The schema parameters are unrelated to timezones (ref, url, city, feed, host, json, path), making correct 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 clear verb and resource: 'Current time in a named IANA timezone.' This conveys the tool's core purpose, but it does not explicitly distinguish it from sibling tools like utc-time or iana-zones, and the input schema contains no obvious IANA timezone parameter.

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 over utc-time or iana-zones, nor does it mention any exclusions or prerequisites. The only implied context is needing the current time in a named IANA timezone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states what is returned, not that the operation is side-effect-free, that input parameters are ignored or discarded, or that no arguments are needed. This gives the agent little information about call behavior beyond the literal output.

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 four words and contains no filler. It is as concise as possible and front-loads the essential point: the tool returns the current UTC timestamp.

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 schema exposes seven unrelated parameters and there are no annotations or output schema, the description is too sparse to be contextually complete. It does not explain why those parameters exist, whether they are optional, or that they are ignored, leaving an agent potentially confused about how to invoke the tool correctly.

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

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

The input schema itself provides descriptions for all parameters, most indicating they are discarded or irrelevant, so schema coverage is high. The tool description adds no meaning to these parameters and does not clarify that they are unnecessary for getting the UTC timestamp, 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 says the tool returns the current UTC timestamp. It lacks a verb like 'get' or 'return', but 'Current UTC timestamp.' is unambiguous and distinguishes it from the sibling 'timezone' tool without opening the schema.

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

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

There is no guidance on when to use this tool versus alternatives such as 'timezone' or 'iana-zones'. The description implies use for the current UTC time, but never states conditions, 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 present, the description carries the behavioral burden. It does disclose that the body is discarded, which signals a non-persistent check, but it omits the return format and what happens on invalid JSON, so the disclosure is only partial.

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

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

Two terse sentences, front-loaded with the operation. No filler, but the ambiguous 'body' and lack of a parameter reference make it less crisp than it could be.

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 an 8-parameter schema, no annotations, and no output schema, the description is too sparse. It should clarify that `json` is the input to validate, that the other parameters are irrelevant or discarded, and what a caller receives in return.

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 gives each parameter a description, so schema_description_coverage is high. However, the tool description itself does not explain which parameter is the 'body' or why unrelated arguments like ref, url, and city appear in the schema, leaving an agent to rely entirely on 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 uses a specific verb-resource pair ('Check whether a body is valid JSON') and is distinguishable from sibling shape/format validators by naming JSON. It is slightly ambiguous whether 'body' means the `json` parameter, but the core purpose is clear.

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 sibling validators or what kind of input it expects. It never says 'use for validating JSON strings as opposed to URLs/hosts/paths', so an agent must infer usage from the name and schema.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the external Open-Meteo source, but does not explain that the tool is read-only, that only the city parameter is used while others are discarded, what the return format is, or how failures such as unknown cities 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 a single, front-loaded sentence with no wasted words. It immediately communicates the core purpose and data source, which is appropriate for a simple tool.

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

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

Despite the simple purpose, the tool has nine optional parameters, no output schema, and no annotations. The description does not explain what the response looks like, which parameters are meaningful, or the fact that most parameters appear to be accepted only to be discarded. An agent could easily be confused about how to invoke it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds a small amount of meaning by indicating that the city parameter is the relevant one, but it does not clarify why nine unrelated optional parameters exist or how they interact with the weather 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 clearly states the tool's function: returning the current temperature for a city, with the data source identified as Open-Meteo. This is specific enough to distinguish it from siblings like geo-hint or timezone, though it does not explicitly name alternatives or contrast itself with other hint tools.

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

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

There is no guidance about when to use this tool versus the many siblings, nor any exclusions or alternative routing. The description only says what the tool does, leaving the agent to infer that it is for weather lookups.

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 reveal that the body is discarded, but it omits response format, error behavior, network/auth implications, and the fact that many schema parameters are described as discarded after checks. This is under-disclosed for a network-fetching tool.

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

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

The description is very concise and front-loaded, with no filler; both sentences provide meaningful information. It is efficient, though the brevity contributes to the mismatch between the stated URL-only purpose and the broad 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 output schema, and no annotations, the description is not complete enough for reliable tool selection and invocation. It does not specify which parameter is authoritative, what success or failure returns look like, or how web-fetch differs from closely related siblings.

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

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

The input schema already documents all nine parameters, so the description does not need to repeat them and the high coverage supports the baseline. However, the description's URL-only framing gives no hint why city, feed, json, path, zone, query, and ref are accepted, leaving the parameter model confusing.

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

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

The description states a concrete operation: return HTTP status and content type for a public URL and discard the body. It is not a tautology and gives the agent a clear primary result, though it does not explicitly distinguish web-fetch from sibling tools like fetch-status or browser-url-ok.

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

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

There is no guidance on when to use this tool versus alternatives such as fetch-status, browser-url-ok, or normalize-url. The only implicit signal is that the body is discarded, so an agent needing body content should look elsewhere, but no explicit when-to-use or when-not-to-use context 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 present, the description carries the full burden of disclosing side effects. It does state that the title is 'discarded after the call,' which is a small privacy/state note, but it never explains whether the check is read-only, whether it contacts Wikipedia, what happens on failure, 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?

The definition is short and front-loaded: the first sentence immediately states the operation. The second sentence about discarding is compact, though it introduces ambiguity by referring to a 'title' that is not present in 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?

For a tool with seven schema parameters, no annotations, no output schema, and several closely related sibling tools, a 14-word description is far from complete. It does not identify which parameter holds the title, specify the result shape, or differentiate this checker from other 'ok'/shape validation 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?

The schema covers 100% of the parameters with individual descriptions, so the baseline would be 3, but the tool description does not map any of those parameters to the stated purpose. None of the seven string fields resembles a Wikipedia title, so the description actually makes the parameter semantics less clear instead of adding useful meaning.

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

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

The description opens with a clear verb and object ('Check whether a Wikipedia title exists'), which states an intent. However, the input schema exposes no 'title' parameter – only ref, url, city, feed, host, json, and path – so the stated purpose cannot be mapped to any actual argument, making the definition misleading in practice.

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 only a bare statement of function; no guidance is given for when to choose this tool over the many sibling '-ok' and shape-check tools, and no exclusions or prerequisites are mentioned. The phrase 'Check whether a Wikipedia title exists' only implies one use case without equipping the agent to select among alternatives.

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