Asia/Yekaterinburg clock

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

With no annotations, the description carries the full burden. It discloses that 'Task text discarded' and that parameters are 'discarded after the check' per the schema, indicating a stateless, non-retained behavior. However, it doesn't mention auth needs, rate limits, or whether it performs any side effects. The 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 zero waste. The purpose is front-loaded, and the note about discarding task text is important and placed at the end. Every sentence 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 parameters, none required, and no output schema, the description is too thin. It lists returned items but doesn't explain how inputs map to the search, what parameters are needed, or what the actual return format looks like. An agent would be unsure what to pass to get the gateway information. The description leaves too much to inference.

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

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

Schema description coverage is 100%, so the schema already explains each parameter's type and purpose. The description adds that 'Task text discarded' and that some parameters are discarded after checks, which hints at a validation-only role. But it doesn't explain how these parameters relate to the gateway lookup or which ones matter, so it adds marginal value over the schema.

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

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

The description states a specific verb and resource: 'Find a public pay-per-call tool gateway (Monid)' and lists what it returns (CLI setup, how-it-works, skill file, remote MCP hops). This clearly distinguishes it from the sibling tools, which are all different focused tools (browser checks, formatting, etc.).

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. It doesn't mention any context where this is preferred, nor does it name any related gateway-lookup tools. An agent must infer its purpose from the name and description 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 of behavioral disclosure. It reveals that no browser is launched, which is useful, but it leaves ambiguous whether network access occurs, how 'can be opened' is determined, and why so many schema parameters are discarded. The description does not explain key runtime behavior.

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

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

The description is a single, front-loaded sentence, with the core purpose stated first and the important caveat second. There is no filler or redundancy. It is appropriately brief, though the brevity contributes to the lack of contextual completeness.

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 exposes 7 heterogeneous parameters, no required-field list, and no output schema, yet the description provides minimal orientation. It does not state which parameter is the URL to check, whether other parameters are optional compatibility shims, or what the caller receives back. The description is inadequate for an agent to confidently call this tool.

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

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

The input schema provides descriptions for all 7 parameters, so the baseline is 3. The tool description itself adds no parameter-level meaning. Furthermore, several schema parameter descriptions (e.g., ref, city, json) appear unrelated to URL checking, and the description fails to clarify how or whether they relate to the core 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: 'Check whether a URL can be opened.' The addendum 'No browser is launched' distinguishes it from sibling tools like playwright-url-ok, giving it a clear identity. However, it does not fully separate it from normalize-url or web-fetch, which also operate on URLs.

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

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

The description implies a lightweight, non-browser URL check, which gives context on when it might be used. But it never explicitly states when to prefer this tool over alternatives like web-fetch, normalize-url, or playwright-url-ok, nor does it mention exclusions or prerequisites.

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 and almost no behavioral disclosure. The description states that an expression is discarded, but does not clarify side effects, return values, error behavior, or whether the tool has any persistent effect.

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 but its second sentence, 'Expression discarded,' actively confuses rather than clarifies. The space is not used to convey necessary information about the evaluation behavior, inputs, or outputs.

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 required parameters, no output schema, and a description that does not tie any parameter to the stated arithmetic purpose, the description is far too incomplete for an agent to call 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?

Although every parameter has a description, the descriptions are irrelevant to arithmetic evaluation (e.g., 'Git ref name; discarded after the shape check', 'City name for a public weather hint'). No parameter corresponds to the expression that is supposedly evaluated, so the schema adds no meaningful semantic guidance.

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 claims to evaluate a+b style arithmetic, but the input schema contains no expression parameter and instead lists unrelated optional strings like ref, url, city, feed, host, json, path, zone, and query. The phrase 'Expression discarded' contradicts the idea of evaluation, leaving the tool's actual purpose 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?

No guidance is provided about when to use this tool versus any sibling tool. The description does not explain what kind of arithmetic expressions are accepted, what inputs are relevant, or what outputs callers should expect.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose that page content is not stored, which is useful, but it does not explain the odd behavior of accepting many unrelated parameters (city, feed, json, zone, query) that appear to be discarded, nor does it describe side effects or return details beyond three fields.

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

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

The description is short and front-loaded, but it is under-sized for a tool with nine parameters and no annotations. While each sentence is economical, important scope information is missing, making it concise but not appropriately sized.

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

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

For a tool with nine optional parameters, no output schema, and no annotations, a two-sentence description is insufficient. It does not explain why city, feed, json, zone, and query parameters are accepted, what the return structure looks like, or how to choose this tool over its many siblings.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning beyond the schema; the schema already documents each parameter, including the 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 clearly states a specific action and resource: return host, scheme, and HTTP status for a URL. However, it does not mention the tool's nine heterogeneous parameters or explicitly distinguish it from siblings like fetch-status or normalize-url.

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

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

No guidance is given about when to use this tool versus alternatives such as fetch-status, normalize-url, or web-fetch. The description provides no context for selecting this tool over its siblings.

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

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

The description discloses one behavioral trait: 'No identifiers are retained,' which complements the schema's repeated discarded-after notes. However, it does not disclose whether the tool is read-only, what side effects (if any) occur, or what the classified output looks like. With no annotations, the description carries the full burden and only partially covers it.

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?

Both sentences are purposeful and front-loaded, making it concise, but the extreme brevity veers toward under-specification. The privacy guarantee earns its place, yet the core classification behavior is so thinly described that conciseness is achieved at the expense of substance.

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 must explain what the classification returns and why an agent would call this tool. It does neither. Given the heterogeneous set of parameters (ref, url, city, feed, host, json, path), the agent is left to guess which input to supply and what result to expect.

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

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

The description adds no per-parameter meaning; however, the schema already documents all seven properties with descriptions (e.g., 'discarded after the shape check'), so schema coverage is high and the baseline 3 applies. The description's blanket privacy note is already implicit in each schema parameter.

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

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

The description states a verb ('Show') and a resource ('how this request is classified'), but 'classification' is ambiguous and the tool's relationship to siblings like normalize-url, citation, and validate-json is unclear. It names neither the input categories nor the output format, so it fails to distinguish itself from similar tools.

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

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

No guidance is given on when to use this tool over alternatives. There is no mention of what request types qualify, what scenarios call for classification, or any excluded conditions. The instruction is left entirely to inference.

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

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

With no annotations provided, the description carries the full burden of disclosing side effects and data handling. It only states what the tool does not do (WHOIS/ownership lookup) and gives no indication of read-only behavior, persistence, or potential side effects. Some parameter descriptions mention 'discarded,' but the main description itself lacks behavioral transparency.

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

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

The description is a single, compact sentence with no fluff and puts the main action first. It is concise and easy to parse, though it omits any structured detail about inputs or outputs, which slightly limits its usefulness.

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

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

Given the tool has nine parameters and no output schema or annotations, the description is too thin to be complete. It does not explain which parameters are required, what the return value looks like, how to handle the apparently unrelated parameters, or how this tool fits among the many siblings.

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

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

All nine parameters have schema descriptions, giving 100% coverage, and the 'host' parameter aligns with the tool's stated purpose. However, the description itself does not clarify the roles of the many other parameters, several of which appear unrelated (e.g., 'city,' 'feed,' 'json'), leaving their relevance to 'domain-shape' unclear.

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

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

The description clearly states the primary action—splitting a hostname into labels—and adds a useful boundary by noting it does not involve WHOIS or ownership data. However, it does not explicitly identify which input parameter (likely 'host') is used, leaving some ambiguity.

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

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

The description offers no explicit guidance on when to choose this tool over alternatives, aside from a vague negative clause about WHOIS/ownership data. It does not mention related sibling tools or typical use cases, so an agent has little basis for deciding when to invoke 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?

With no annotations, the description carries the full behavioral burden. It discloses that a HEAD request is made to a public URL and that only the status is returned, but it does not explain the response format, timeout/redirect behavior, or the role of the many 'discarded' schema parameters, leaving significant behavioral ambiguity.

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

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

The description is a single front-loaded sentence with no filler; every word contributes to the core instruction. It is concise and easy to parse, even though other dimensions need more 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 9 optional parameters, no annotations, and no output schema, the one-sentence description is insufficient. It does not specify the return value shape, error behavior, or which parameter is actually used, so an agent has to guess 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 that the URL is the target of the HEAD request and must be public, but it does not clarify how the other eight optional parameters relate to the stated behavior or whether they are intentionally 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 'HEAD a public URL and return status only' names a specific verb, resource, and outcome, which clearly conveys the core action and separates it from full-fetch tools like web-fetch. However, it does not explicitly distinguish itself from sibling status-oriented tools such as browser-url-ok or playwright-url-ok, and the 9-parameter schema with unrelated fields like city, json, and path is left unexplained.

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

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

There is no guidance about when to use fetch-status versus alternatives such as web-fetch, browser-url-ok, or normalize-url. The phrase 'return status only' implies a lightweight status check, but no exclusions, prerequisites, or alternative-selection cues are provided.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, yet it reveals only one trait: 'Path discarded.' It does not state validation semantics, the output format, error behavior, or how the 8 unrelated parameters (city, feed, json, zone, query) factor in. Parsing implies read-only intent, but that is implicit, not disclosed.

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

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

Two short sentences with zero filler: the core resource is front-loaded and the distinguishing behavioral caveat ('Path discarded') follows immediately. 'Path discarded' is a fragment, but it earns its place as the key scoping constraint.

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

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

For a tool with 9 parameters, no annotations, and no output schema, this description is far too thin. It doesn't explain what the parse returns, what constitutes a valid Figma URL, or how the unrelated parameters (ref, city, feed, host, json, zone, query) are handled, leaving the agent to infer nearly everything from schema descriptions alone.

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 every parameter already has a description, meeting the baseline. The tool description adds essentially nothing about parameters and does not explicitly map 'Figma file URL' to the url parameter; there is also a subtle mismatch where url is generically described as 'HTTPS URL to normalize or cite' rather than as a Figma URL.

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

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

The description states a specific verb and resource ('Parse a Figma file URL') that aligns with the tool name and distinguishes it from sibling shape tools like github-repo-shape and jira-key-shape. The 'Path discarded' clause adds a scoping detail, though it is terse and doesn't clarify what the parse produces.

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

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

There is no guidance on when to use this tool versus the many sibling URL/shape tools (browser-url-ok, normalize-url, github-repo-shape, file-path-ok), and no mention of which of the 9 parameters should hold the Figma URL. The only routing signal is the tool's name 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?

With no annotations, the description carries the behavioral burden. It does disclose a key behavior: 'No disk access,' which tells the agent the check is purely syntactic and side-effect-free. It does not explain what 'safe' means, what the return value looks like, or whether it normalizes or just validates, so transparency is only partial.

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

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

Two short sentences, no filler, and the primary behavior plus the safety caveat are front-loaded. 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?

Despite high schema coverage, the description omits the output contract (e.g., boolean result), what 'safe' means, and how the many unrelated optional parameters relate to the path check. With no annotations and no output schema, the agent is left with insufficient operational context.

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

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

Schema description coverage is 100%, so the baseline is 3; all nine optional parameters already have individual descriptions. The tool description adds no parameter semantics of its own and does not even indicate that `path` is the operative parameter among the many 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 states a specific action ('Check whether a path looks safe') and resource ('path'), and the 'No disk access' addition clarifies the scope. However, it does not explicitly distinguish from sibling validators such as browser-url-ok or wiki-title-ok, so an agent must infer the differentiation from the 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?

There is no statement about when to use this tool versus alternatives or when not to use it. The phrase 'Check whether a path looks safe' implies a validation use case, but with many sibling shape/validator tools, the lack of explicit routing leaves the agent to guess.

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 reveals the provider, Open-Meteo, and does not explain whether this is an external network lookup, whether it is read-only, what happens with unrelated-looking parameters, or what error/rate-limit behavior to expect.

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 a single short sentence with no filler and the core idea is front-loaded. It loses some credit because it is a fragment with no action verb, but it is appropriately compact for the little it conveys.

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 optional parameters, no output schema, no annotations, and many sibling hint tools, the one-line description is not sufficient. Critical details about which parameter to provide, what the returned hint contains, and why the schema has many unrelated-looking fields are all 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?

All seven schema parameters have descriptions, which normally establishes a baseline of 3, but the tool description's 'place' maps to no obvious parameter. The only place-like field, city, is described as 'discarded after the call,' so the description and schema together do not tell the agent which input actually produces latitude and longitude.

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

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

The description clearly communicates that the tool is meant to supply latitude and longitude for a place and names Open-Meteo as the source. It is not a tautology, but it lacks an explicit verb and does not distinguish geo-hint from coordinate-adjacent siblings such as weather-hint.

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

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

There is no guidance about when to choose this tool over weather-hint, timezone, or other sibling tools. No alternatives, exclusions, or contextual triggers are mentioned, so the agent is left to guess whether geo-hint is the right call.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It only says 'parse', which implies a read-only computation, but it never states whether the tool makes network calls, how invalid or non-GitHub URLs are handled, what the exact return shape is, or that unrelated parameters are discarded. With no output schema, an agent has little information about what to expect.

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 tight, front-loaded sentence with no redundant wording. It is efficient, but it is also too terse for a tool whose schema carries seven optional parameters and no annotations, so brevity comes at the cost of missing contextual structure.

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

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

With no annotations, no output schema, and a seven-parameter schema, a single sentence is not enough for an agent to invoke the tool confidently. The description omits how to supply the required input, what happens with invalid URLs, what the return representation is, and why most schema fields appear unrelated to the stated purpose.

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 parameters already have descriptions in the schema, which sets the baseline at 3. The tool description adds meaning by clarifying that the `url` parameter is specifically a GitHub URL from which `owner` and `repo` are parsed, going beyond the schema's generic 'HTTPS URL to normalize or cite'. It does not explain why city, feed, json, and path are present, so it cannot reach a 5.

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 ('parse'), a resource ('GitHub URL'), and a concrete outcome ('owner and repo'), which distinguishes it from sibling shape tools like figma-url-shape and jira-key-shape. It loses the top score because the input schema exposes many unrelated fields (city, feed, json, path) that are never reconciled with the stated GitHub-URL-only scope.

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

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

The phrase 'from a GitHub URL' gives a clear but implicit usage signal: this tool is for extracting owner and repo from a GitHub link. However, the description does not explicitly state when to use it over other shape tools, nor does it mention exclusions or alternatives. It is enough for basic selection but not well-grounded 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 provided, so description carries the burden. It hints at behavior with 'Titles discarded' but does not clarify side effects, output format, failure modes, or whether it fetches live data. Does not contradict annotations because none exist.

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

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

Very brief and front-loaded with purpose; no filler. However, 'Titles discarded' is cryptic and could be replaced with clearer output semantics while staying 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 definition is incomplete for a tool with nine optional parameters and no output schema. It doesn't explain what the parameters mean for this tool, what the count result looks like, or error/edge cases. Minimal purpose only.

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

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

Schema descriptions cover 100% of params, but they are generic and mismatched for this tool (e.g., 'Git ref name', 'City name for a public weather hint'). The description provides no mapping to the count operation, so an agent cannot discern which of the nine optional parameters, if any, affects the count.

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

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

States a specific action 'Count' and object 'current Hacker News front-page stories', making the core function clear. The phrase 'Titles discarded' is ambiguous, and no sibling differentiation is offered, but the verb/resource pair is enough to orient an agent.

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?

Provides no guidance on when to choose this tool over alternatives, despite sibling tools like web-fetch, normalize-url, and browser-url-ok. No explicit condition or exclusion is stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether the tool is read-only, what it returns, whether inputs are discarded, or any side effects. The input schema mentions discard behavior, but the tool description itself is silent on actual behavior.

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

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

The description is very short and front-loaded, which is good for scanability. However, it sacrifices necessary detail to the point of being under-specified, so the brevity is not fully an asset.

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

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

With seven parameters, no annotations, and no output schema, the description is far too minimal. An agent cannot determine how to select a parameter, what arguments are expected, what the tool returns, or when it should be invoked.

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 parameters have individual schema descriptions, so schema coverage is effectively 100%. Per baseline, the description need not repeat parameter details; however, it also adds no meaning about how the parameters relate to IANA timezone names, so it earns no credit 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 names the resource ('Common IANA timezone names') and its context ('for clock calls'), but lacks an explicit action verb such as 'list' or 'return'. It is understandable but does not strongly differentiate from sibling tools like 'timezone' or '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?

The phrase 'for clock calls' gives a clear intended context, but the description does not explain when to prefer this tool over alternatives, nor does it mention any exclusions. Usage guidance is only implied, not 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?

The description adds useful behavioral context beyond the name: it is a public fetch and returns only group counts, suggesting a read-only, limited-output operation. Since no annotations are provided, the description carries the burden, but it does not disclose failure modes, output format, or what exactly 'group counts' includes.

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 is concise, though the brevity leaves key invocation details out; conciseness itself is good.

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, no output schema, and many sibling tools, the description is not complete enough. An agent cannot determine which parameter to populate, what output to expect, or how to distinguish this from related fetch/shape 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?

Although schema description coverage is 100%, the descriptions are generic and largely unrelated to robots.txt (e.g., city, feed, json, zone, query). The tool description never identifies which parameter should contain the robots.txt URL, and the 'url' parameter is described as 'normalize or cite' rather than fetch. This is a serious invocation gap.

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

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

The description names a specific verb and resource: 'Fetch a public robots.txt' and states the narrow result 'return group counts only.' This distinguishes it from generic fetchers like web-fetch, though it does not explicitly name a sibling. The purpose is understandable at a high level.

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 'return group counts only' implies that this tool is for summary counts rather than full robots.txt content, so an agent could infer when to use it. However, it does not explicitly mention alternatives or state when not to use it, leaving the routing decision mostly 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 and a terse description, the tool does not disclose what it returns (e.g., boolean), error behavior, or side effects beyond noting the key is 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 brief and to-the-point, but it sacrifices essential detail about the input parameter, making brevity a detractor rather than an asset.

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's nine optional parameters and lack of an output schema, the description is severely incomplete—it fails to explain the parameter mapping, expected usage, or result format.

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 includes nine parameters with descriptions like 'Git ref name' and 'HTTPS URL' that have no obvious relationship to a Jira issue key, making it impossible to determine which parameter to pass.

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

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

The description clearly states the action ('Check') and the target ('Jira issue key shape'), but it does not specify which of the nine parameters holds the key, leaving the purpose partially 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?

No guidance is provided on when to use this tool versus similar shape-validation siblings like domain-shape or github-repo-shape, and there is no mention of typical use cases.

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

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

No annotations are provided, so the description carries the disclosure burden. It does reveal that the HTTP body is discarded, which is useful behavioral context. However, it does not mention whether a network request is actually made, any timeouts, caching, or 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 no filler. The core purpose is front-loaded and the body-discarded caveat is economically stated.

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

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

With nine optional parameters, no output schema, and no annotations, the description is far too sparse. It does not explain which parameter is the library docs URL, whether multiple parameters can be passed, or why unrelated fields for weather, timezone, JSON, and search queries exist in 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 even though the tool description adds no parameter-level explanation. The description's 'library docs URL' focus does not align cleanly with the schema's 'url' parameter description ('normalize or cite'), so it adds no clarifying 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 names a specific action and resource: returning an HTTP status for a public library docs URL. It does not explicitly differentiate this from sibling status tools like fetch-status or browser-url-ok, and the broad nine-parameter schema makes the actual target less obvious.

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

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

There is no guidance about when to use this tool versus the many sibling URL/status tools, nor any mention of exclusions or alternatives. An agent gets no help deciding between lib-docs-hint, fetch-status, browser-url-ok, or normalize-url.

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

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

With no annotations, the description carries the behavioral disclosure burden. 'Values discarded' is a useful disclosure that values are ignored and not used. But it does not mention side effects, return value, or behavior with an empty object or missing keys.

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 operation and no filler. 'Values discarded' earns its place by clarifying 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?

For a 9-parameter tool with no annotations and no output schema, this is under-specified. It does not clarify what the returned count represents, whether all schema keys are counted or only supplied keys, or how to pass the JSON object. The rich sibling list only makes the missing positioning more noticeable.

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 a baseline of 3 is warranted, but the description creates a mismatch: it refers to a JSON object while the schema only exposes nine flat string properties and no object parameter. The candidate 'json' parameter is described as JSON text to validate, which points to validation rather than counting. The description adds no guidance on which parameters to supply.

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

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

The description uses a specific verb and resource ('Count keys in a JSON object') and adds a meaningful qualifier ('Values discarded'). It is clearly distinguishable from sibling tools like validate-json, which validates rather than counts. However, it does not explicitly connect the 'JSON object' to the actual input parameters.

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 or when-not-to-use guidance is provided. The description does not mention alternatives or explain when counting keys would be preferable to validation or other sibling operations.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It transparently reveals the key non-obvious behavior: query and fragment are dropped. It does not mention invalid-input handling or whether any network fetch occurs, but for a pure normalization tool the main lossy behavior is disclosed.

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

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

Two short sentences with no filler. The main action and output are front-loaded, and the critical caveat about dropped query/fragment is placed immediately after. Every word earns its place.

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

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

The description is too thin for a tool with no annotations, no output schema, and a seven-property schema containing decoy fields. It does not state that 'url' is the primary input, does not specify the output shape (object keys vs. array), and does not clarify how this tool differs from the many URL-related siblings. An agent could plausibly pass 'host' or 'path' as inputs or expect a return format that is not described.

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

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

The schema already describes the parameters, and the 'url' property is marked as the HTTPS URL. The description adds that query/fragment are dropped, which is useful, but it never directly says to populate the 'url' parameter and leaves 'host' and 'path' ambiguous given they appear both as outputs and as input properties.

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 resource ('URL') and names the exact outputs: origin, host, and path, plus the dropped query/fragment behavior. It is clear and distinct, though it does not explicitly distinguish itself from sibling URL-related 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 by the name and output description, but there is no explicit 'when to use this vs. alternatives' guidance. In a sibling set containing web-fetch, browser-url-ok, and fetch-status, the tool selection context is under-specified.

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 only discloses that no browser is launched; it does not mention network behavior, side effects, what 'opened' means, or what the caller receives. For a tool with no annotation safety hints, this is a significant gap.

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

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

The description is extremely concise: two short sentences with no filler. The key behavioral caveat ('No browser is launched') is front-loaded and useful. It loses one point because it is so terse that it omits needed context for the 9-parameter schema.

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

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

For a tool with 9 heterogeneous parameters, no output schema, and no annotations, this description is far from complete. It does not specify return values, how 'can be opened' is determined, whether parameters are mutually exclusive, or how the listed params map to the check. The schema descriptions help but the tool description itself leaves major 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 every parameter already has a description and the baseline is 3. The tool description itself adds no parameter-level meaning and does not explain why parameters like city, feed, ref, or zone relate to checking a URL, but the schema already handles individual 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 states a specific action — 'Check whether a URL can be opened' — with a clear resource (URL), and the clause 'No browser is launched' helps distinguish it from browser-based siblings like browser-url-ok. However, it does not explain what mechanism is used instead, leaving some ambiguity about what 'can be opened' means.

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 explicit when-to-use or when-not-to-use guidance, and it never names alternatives. The 'No browser is launched' hint implicitly separates it from browser-url-ok, but the agent is left to infer when this tool should be selected over fetch-status, normalize-url, or other URL-related siblings.

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

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

No annotations are provided, so the description carries the full burden. 'Query discarded' is a useful privacy/retention disclosure and indicates no lasting side effects, but the description does not explain what the tool returns, how characters are counted, or any other behavioral constraints.

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 function and the disposal behavior are front-loaded. It is appropriately concise for a simple tool, though adding the target parameter name would make it more useful without hurt.

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 too sparse given the broad, weakly related schema and the absence of annotations or an output schema. An agent needs to know which parameter to populate, what the return value looks like, and any character-counting conventions; none of that is provided.

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

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

The input schema has 12 properties but no 'query' property, and the description never maps 'search query' to a specific parameter. The schema's own description for 'text' does say 'Text to count characters in', which aligns, but the lack of an explicit mapping in the tool description creates real invocation ambiguity, lowering the baseline.

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

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

The description states a concrete operation—count characters in a search query—and the disposal note helps set it apart from sibling tools that normalize, validate, or fetch. It is clear enough, but it relies partly on the tool name and does not explicitly contrast with related 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 on when to use this tool versus alternatives, nor any mention of prerequisites or exclusions. The only implicit context is that it is for counting characters in a search query, which is not enough to route an agent confidently among many similarly named sibling tools.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. 'Short catalog' weakly implies a read-only reference resource, but it does not state whether the tool has side effects, whether it reads or returns data, how the inputs affect behavior, or what output format to expect.

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

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

The single sentence is short but not usefully concise; it is under-specification rather than tight communication. A 14-word noun phrase cannot carry the selection, usage, and behavioral burden of a seven-parameter tool.

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

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

Given seven optional parameters, no annotations, and no output schema, the description is materially incomplete. It does not explain what the catalog returns, which parameter triggers which behavior, or whether this is a static reference or an active checking 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?

All seven parameters have descriptions in the input schema, so schema coverage is high and the baseline is 3. The tool description adds no parameter meaning beyond the schema, and it fails to explain why fields like city, feed, or path appear in a tool about HTTP status codes, but it does not mislead about them.

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 domain (HTTP status codes) and says the tool exposes a short catalog, which is more specific than the bare name. However, it uses no action verb and gives no contrast with sibling tools like fetch-status or domain-shape, so an agent cannot tell exactly what invoking the tool does.

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

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

There is no guidance about when to choose this tool over alternatives such as fetch-status or normalize-url. The schema hints at several possible inputs (url, json, path, etc.), but the description never explains which parameter selects which use case or how they relate to a status-code catalog.

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?

Without annotations, the description carries full responsibility for disclosing behavior. It explicitly states that the prompt is discarded, informing the agent that input is ignored and the output is a fixed template. This is a key behavioral trait that goes beyond the tool's name and schema. It could also mention that all parameters are similarly ignored, but the schema fills that gap, so this is solid.

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, tightly worded sentence with no filler. It front-loads the core purpose ('Return a three-step thinking template') and immediately follows with the essential behavior ('Prompt discarded.'). Every word earns its place.

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

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

For a tool that simply returns a fixed template, the description covers the key fact: the output is a three-step thinking template. It also teases that the prompt is irrelevant, so an agent knows it can call the tool with empty arguments. No output schema exists, but the return value is stated. The only minor gap is not explicitly saying 'all arguments are optional', but the schema's optional fields and the description's discard note make this clear enough.

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, each explicitly noting that the value is discarded after a check or entirely. With 100% schema coverage, the baseline is 3. The description's 'Prompt discarded.' adds a general note about input handling but does not enhance specific parameter understanding beyond what the schema already states.

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 output: 'Return a three-step thinking template.' This clearly identifies the tool's function as a template provider, distinct from siblings like timezone or validate-json which process inputs. The added 'Prompt discarded.' further clarifies that it does not analyze input, removing ambiguity about its role.

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

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

The description implies when to use the tool: whenever a three-step thinking template is needed. However, it offers no exclusions, no comparisons to alternatives, and no guidance on circumstances where another tool might be better. The usage context is inferred rather than explicit, earning a 3.

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 states the result and does not mention output format, error behavior, network dependencies, or that the provided schema properties such as ref, url, json, and path appear unrelated or discarded. The description also creates an unresolved mismatch: it requires a named IANA timezone, but the schema exposes no timezone parameter.

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

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

The one-sentence description is economical and front-loaded, but it is under-specified: it does little more than state the tool's obvious purpose and omits the essential mapping between the described timezone input and the actual 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 no annotations, no output schema, and an 8-property schema whose parameters are irrelevant to timezone lookup, the description is far from complete. It fails to identify which parameter carries the IANA timezone or to explain why the schema does not match the stated 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?

Although every schema property has a description, none accepts an IANA timezone identifier; the properties describe Git refs, URLs, cities, feeds, hosts, JSON, and paths. An agent cannot derive how to supply the 'named IANA timezone' the description requires, so the parameter information is actively unhelpful 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 names the specific operation ('Current time') and resource ('named IANA timezone'), which distinguishes it at a glance from sibling tools like 'iana-zones' (listing zones) and 'utc-time' (current UTC time). It does not explicitly reference siblings, 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?

No explicit when-to-use or when-not-to-use guidance is given, and no alternative tools are named. The phrase 'IANA timezone' implies use for zone-specific time rather than for utc-time or listing zones, but the agent must infer this rather than being told.

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 only that a UTC timestamp is returned, but does not explain whether parameters affect the result, that they are largely ignored or discarded, or what output format is produced.

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 filler, making it easy to parse and remember. It lacks additional structure, but conciseness is appropriate for such a minimal 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 tool being conceptually simple, the presence of nine optional but seemingly unrelated parameters creates ambiguity that the description does not resolve. There is no output schema, and the description does not state the return format or clarify whether any parameters should ever be passed.

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 adds no parameter-level meaning, but the input schema already documents each parameter, mostly noting that values are discarded or shape-checked.

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

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

The description clearly states the tool returns the current UTC timestamp, which is a specific and identifiable outcome. It is distinguishable from siblings like timezone and iana-zones by name and purpose, though it does not explicitly call out those distinctions.

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 prefer this tool over alternatives such as timezone or iana-zones, nor any context for when it should be called. There are no exclusions, prerequisites, or alternative tool references.

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

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

With no annotations, the description carries the transparency burden. It usefully discloses that the body is discarded, indicating a non-persistent check, but it does not explain return values, validation failure behavior, or size/format limits.

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, front-loads the core purpose, and avoids filler. The second sentence adds a meaningful behavioral note about disposal, so no sentence is wasted.

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

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

The definition is incomplete for a tool with no output schema and a seven-property input schema. It does not say which parameter carries the JSON, what a valid result looks like, or what happens on invalid input, leaving an agent to infer critical calling details.

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

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

The input schema has property descriptions for every parameter, so schematically this is well covered. The tool description adds no parameter-level meaning and its use of 'body' does not map cleanly to the schema's 'json' field, but the schema already documents 'JSON text to validate; discarded after the check.'

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 body is valid JSON.' It distinguishes the tool as a JSON validation action, though it does not differentiate from sibling validation tools like domain-shape or file-path-ok, and 'body' is not mapped to a stated 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 explain when to use validate-json instead of sibling tools such as normalize-url, domain-shape, or fetch-status, nor does it mention exclusions or prerequisites.

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 of disclosure. It names the external data source (Open-Meteo) and implies a read-only lookup, but it does not mention network implications, failure modes, or units. This is adequate but thin.

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

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

A single front-loaded sentence with no filler. The essential behavior and data source are stated immediately and memorably.

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 and no output schema, the description is too minimal. It omits the output format or units, which city parameter is actually used, and the relevance of the other schema fields. An agent could still succeed, but the description leaves too much to inference.

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

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

The schema already documents every parameter, and the phrase 'for a city' points the agent to the `city` field. However, the schema lists many unrelated parameters with 'discarded' semantics, and the description adds no format or unit details beyond the schema.

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

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

The description clearly states that the tool returns the current temperature for a city using Open-Meteo. The resource and operation are easy to identify, though it does not explicitly contrast with any sibling tool.

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: call it when you need a city's current temperature. There is no explicit when-to-use or when-not-to-use guidance, and no alternatives are mentioned.

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

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

With no annotations, the description carries the behavioral disclosure burden. It does reveal a meaningful trait: the response body is discarded, so only status and content type are returned. However, it does not mention redirects, error behavior, rate limits, or response format, leaving clear 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 sentences with no filler; the main purpose is front-loaded and the key caveat about the discarded body follows immediately. Every word earns its place.

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

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

For a tool with 9 optional parameters, no annotations, and no output schema, this description is too thin. It never explicitly says 'provide the URL in the url parameter,' leaving ambiguity with host, and it does not describe what happens on failure or the exact shape of the returned status/content type information.

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

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

Schema coverage is 100%, so each of the 9 parameters already has a description; the tool description adds no new parameter-level meaning. The main text does not clarify which parameter is the primary URL input, and the schema's description of 'url' ('normalize or cite') does not perfectly align with the stated fetch behavior, but the baseline remains 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 clearly states a specific verb and resource: it returns HTTP status and content type for a public URL, and explicitly notes that the body is discarded. This is non-tautological and immediately informative, but it does not differentiate itself from sibling tools such as fetch-status or browser-url-ok, so it stops short of a 5.

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

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

There is no guidance on when to use this tool versus its siblings like fetch-status, normalize-url, or browser-url-ok. The phrase 'public URL' implies a precondition, but no exclusions, alternatives, or preferred scenarios are described.

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 stand alone. It mentions 'Title discarded after the call' but does not disclose other behaviors like read-only nature, network usage, or error handling, leaving the agent with minimal information.

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, with two short sentences, and front-loads the primary purpose. No wasted words or irrelevant info are present.

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 fails to explain how to use the tool given the 9 irrelevant parameters, lacks a return value specification, and omits any context about the actual input for the title. It is incomplete even for a simple existence 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?

The schema properties (ref, url, city, feed, host, json, path, zone, query) are completely unrelated to checking a Wikipedia title, and the description does not clarify which parameter (if any) represents the title. The schema descriptions actively mislead (e.g., 'Git ref name' for ref), so the description adds no semantic 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 clearly states the verb ('check') and the resource ('Wikipedia title existence'), which is specific and distinguishes it from sibling tools that check other resources.

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

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

The description provides no guidance on when to use this tool versus alternatives, no mention of prerequisite conditions, and no exclusions or use cases.

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