Currency DKK

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotenceHint=true, so the safety profile is covered. The description adds the fact that task text is discarded and describes the output payload (CLI setup, how-it-works, skill file, remote MCP hops). However, it doesn't disclose whether any of the schema parameters are actually used or whether the returned artifacts are fetched from a remote endpoint.

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

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

Three short sentences, front-loaded with the purpose, followed by the output summary and a behavioral caveat. No 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?

The description is sufficient for a simple lookup but leaves the relationship between the seven schema parameters and the gateway-finding purpose unexplored; it's unclear what input actually selects the gateway, and the 'Task text discarded' hints at an input that is not in the schema. The absence of an output schema makes the returned artifact list helpful but not detailed enough to know how to consume them.

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 provides descriptions for all 7 parameters (100% coverage), mostly noting they are discarded after validation or use, so the tool description adds no additional parameter meaning. Baseline 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?

States a specific action ('Find') and resource ('public pay-per-call tool gateway (Monid)'), and enumerates the returned artifacts (CLI setup, how-it-works, skill file, remote MCP hops). The Monid gateway reference distinguishes it from the sibling tools, none of which mention this service.

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

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

The description implies the tool is used when an agent needs a pay-per-call tool gateway, but it does not explicitly state when to prefer it over alternatives or provide exclusion criteria. The 'Task text discarded' note warns that task input is ignored, which is a useful constraint, but it never names a sibling tool or condition for choosing this one.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says that no browser is launched, but omits what 'can be opened' actually means, how the check is performed, whether redirects are followed, what status codes are considered successful, or whether any discarded inputs are truly unused. This is too thin for an agent to predict side effects or failure modes.

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 the primary action front-loaded and the second sentence providing a useful behavioral caveat. Both sentences earn their place, and there is no filler or redundancy.

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

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

This tool has no output schema, no annotations, and seven loosely related parameters, yet the description does not explain what a successful check returns, which parameter is canonical, or how the extra fields relate to the stated URL check. An agent would be left guessing about the invocation contract, especially given the crowded sibling-tool list.

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 individual schema descriptions, so schema_description_coverage is high and the baseline is 3. The tool description itself adds no parameter-level meaning and does not explicitly tie the stated URL check to the `url` field, and the schema's `url` description ('HTTPS URL to normalize or cite') muddies the relationship. Still, parameter names and descriptions give an agent enough to make a reasonable selection.

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'), the resource ('URL'), and the intended outcome ('can be opened'). The 'No browser is launched' caveat also helps distinguish it from playwright-url-ok. However, it does not explicitly differentiate itself from similar URL-related siblings like fetch-status or web-fetch.

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

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

There is no explicit guidance about when to use this tool versus alternatives such as playwright-url-ok, fetch-status, or web-fetch. The 'No browser is launched' note implies a limitation but does not state a recommended use case, exclusions, or prerequisite conditions.

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

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

With no annotations provided, the description carries the full burden of disclosing side effects and return behavior. It adds only 'Expression discarded,' which reveals limited information and does not explain what the tool returns, whether it is a safe read, or how the expression is interpreted.

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 with the main action front-loaded, and it contains no filler. However, 'Expression discarded' is not clearly useful and the definition is too terse for the complexity of the nine-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 no annotations, no output schema, and a highly heterogeneous nine-parameter schema, this description omits the essential input mapping and return behavior. An agent has no way to know how to invoke the tool correctly, so the definition is fundamentally incomplete.

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

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

Schema descriptions cover all 100% of parameters, so the baseline is 3, but the parameter descriptions are all generic discarded/check strings unrelated to arithmetic. The tool description fails to identify which, if any, parameter represents the expression, so it adds confusion rather than useful 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 states a concrete action ('Evaluate a+b style arithmetic'), so it is not a tautology, but it never connects that action to any of the nine schema properties. None of the properties is an arithmetic expression and most are explicitly marked 'discarded,' making the tool's actual purpose ambiguous and effectively misleading.

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 of when to use this tool, when not to use it, or how it compares with sibling tools. The only implied usage is arithmetic evaluation, but that guidance is not actionable because the schema offers no field through which an expression can be supplied.

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

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

With no annotations provided, the description carries the transparency burden. It explicitly discloses that page content is not stored, which is a meaningful privacy and side-effect guarantee. It does not cover error behavior or redirects, but the disclosure goes beyond a bare purpose statement.

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 the output front-loaded in the first and a key caveat in the second. There is no redundant wording.

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

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

The description is adequate for a simple URL checker, but it is not fully complete given the multi-parameter schema and lack of output schema or annotations. It does not explain how the other parameters relate to the described behavior or what happens on invalid URLs, so an agent must infer some behavior from the schema.

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

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

Schema description coverage is 100%, so the baseline applies. The description adds that the tool operates on a URL, matching the 'url' parameter, but it does not clarify the role of the six other parameters such as city, feed, json, and path, which is confusing given the narrow 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 states a specific verb ('Return'), resource ('URL'), and output tuple ('host, scheme, and HTTP status'). It is clear, but it does not explicitly differentiate itself from sibling tools such as fetch-status or normalize-url, which overlap in output 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 only usage hint is 'Page content is not stored,' which implies this tool is for metadata rather than content retrieval. However, it never names alternative tools like web-fetch or states when to prefer this tool over them, leaving the routing to inference.

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

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

With no annotations, the description carries the behavioral disclosure burden; it does add one useful trait: 'No identifiers are retained.' However, it remains silent on whether URLs/feeds are fetched, whether file paths are read, what side effects the check might have, and what output the caller should expect, so the disclosure 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?

The description is admirably short and front-loaded, but it is under-specified rather than efficiently complete. For a tool with 9 optional parameters and no output schema, two sentences omit too much essential behavior to be considered well-structured.

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

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

The tool has 9 parameters, zero required ones, no output schema, and many sibling tools, yet the description does not explain what classifications exist, whether one parameter or several should be supplied, how the result is structured, or when this tool is preferred over a sibling. This is a significant completeness gap.

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

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

Schema description coverage is 100%, so the input schema already documents each of the 9 parameters. The tool description adds no parameter-level meaning, but the baseline of 3 applies because the description is not required to repeat 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, 'Show,' and names a general object, 'how this request is classified,' but never explains what 'classified' means or that this is a compatibility assessment. It does not refer to the tool name and gives no signal that would help an agent distinguish it from nearby sibling tools like domain-shape, validate-json, or normalize-url.

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

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

There is no guidance on when to use this tool versus the many sibling tools, no contextual trigger, and no exclusions. The only non-purpose sentence, 'No identifiers are retained,' is a privacy guarantee, not a usage guideline.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure, yet it only states the core split operation. It does not reveal return format, handling of invalid hostnames, case/IDN normalization, or whether any network/disk access occurs; 'without WHOIS' is the only behavioral boundary.

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, and both parts ('split a hostname' and 'without WHOIS/ownership data') carry meaning. It is appropriately terse but not padded.

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

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

Despite a clear one-line purpose, the definition is incomplete relative to its context: no output schema exists, so return shape is not explained; there are 9 optional parameters and the description does not state that only `host` is relevant; and error/edge-case behavior is absent. An agent could guess the input but not the result 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 coverage is 100%, so param semantics are already fully documented in the schema. The description adds only the clue that 'hostname' maps to the `host` parameter; it does not add format details beyond the schema, keeping this at the high-coverage 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 names a specific verb ('Split') and resource ('a hostname'), and the phrase 'without WHOIS or ownership data' clarifies it is a syntactic shape utility rather than an ownership lookup. It does not explicitly name a sibling tool, so it stops short of full differentiation, but the intended operation is unmistakable.

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

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

There is no statement of when to prefer this over alternatives, nor any named sibling or excluded alternative. The 'without WHOIS or ownership data' clause hints at a non-usage, but no explicit when-to-use guidance or routing to another tool is provided.

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

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

With no annotations, the description carries the burden of behavioral disclosure and does state the HTTP method (HEAD) and the limited return (status only). However, it says nothing about redirects, timeouts, error behavior, or how the extra schema parameters are treated, which is a meaningful gap for a nine-parameter 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?

One tight sentence with no filler; the method, target, and return scope are all front-loaded. Every word earns its place and the description is easy to parse.

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

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

There is no output schema and no annotations, while the input schema advertises nine independent optional parameters. The description covers only the URL-status use case and gives no guidance on how to interpret results or how to treat the other parameters, so an agent cannot confidently use the full tool 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?

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level detail and does not clarify which of the nine optional parameters is actually used for the URL HEAD request, though the `url` parameter description partially fills that 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 clearly states the verb (HEAD), resource (a public URL), and output (status only), which distinguishes it from content-fetching siblings like web-fetch. However, it does not acknowledge the nine unrelated optional parameters in the input schema, leaving the tool's overall purpose only partially specified.

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 given, and no alternatives are named. The phrase 'status only' implies a lightweight status check, but the agent is left to infer the boundary against sibling tools like browser-url-ok or web-fetch.

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 behavioral disclosure burden. It reveals only that the path is discarded, but does not clarify whether the tool validates, fetches, returns a normalized result, or how it treats the remaining URL components. 'Parse' remains ambiguous.

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

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

The description is two short sentences with no filler, and the core purpose is front-loaded. It is appropriately terse, though a line about return behavior would improve structure without harming conciseness.

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

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

Given a 9-parameter schema, no output schema, and no annotations, this description is too thin. It does not explain what the parse returns, how the other parameters relate to the Figma URL, or what a valid Figma file URL looks like, leaving an agent uncertain about the tool's full behavior.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds a small clarification that the input is a Figma file URL and that the path is discarded, but it does not meaningfully explain the role of the other eight parameters 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 clearly states that the tool parses a Figma file URL, which is a specific verb and resource. It does not explicitly differentiate this from sibling shape tools like github-repo-shape or jira-key-shape, so it misses the top 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?

There is no guidance about when to use this tool versus alternatives such as normalize-url or browser-url-ok. The intended use is only implied by the tool name and phrase 'Figma file URL'; no conditions, exclusions, or alternative routing 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?

The explicit 'No disk access' is a meaningful behavioral guarantee, especially since no annotations are provided. However, the description does not state the return type, what 'safe' means, or error behavior, leaving much of the behavioral burden uncovered.

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 check is front-loaded and the side-effect guarantee is second. It earns its brevity, though it could have used the space to define 'safe' without becoming verbose.

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 output schema, no annotations, and a 9-parameter schema, this description is too thin. It fails to specify which parameter to supply, what the returned result looks like, or the criteria for 'safe', so an agent cannot fully predict invocation or results.

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 the path parameter is documented as 'File path to check', so the baseline of 3 applies. The tool description adds no detail beyond naming 'path' and does not clarify why many unrelated optional parameters exist 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 concrete action and resource: checking whether a path looks safe, which distinguishes it from sibling URL/domain/title validators. It is not a pure tautology because 'No disk access' clarifies the check is static, though 'safe' remains undefined.

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, and no alternative tools are named. 'No disk access' only implies it is a non-I/O validation, but the description does not say to prefer it for path validation before disk 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?

No annotations are present, so the description carries the full burden of behavioral disclosure. It names Open-Meteo as the source but does not disclose the return format, network dependency, failure behavior, or that input values are discarded after the operation.

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

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

One short sentence that front-loads the core purpose and provider. It is appropriately concise, though it sacrifices useful details better covered under other dimensions.

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

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

Given nine optional parameters, no output schema, and no annotations, the description is too thin to let an agent confidently invoke the tool correctly. It does not explain the result format or which input parameter represents the place.

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

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

The schema has 100% description coverage, so the baseline is 3 even without parameter details in the tool description. The description adds no extra parameter guidance and does not clarify which of the nine optional fields supplies the 'place,' creating potential ambiguity.

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

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

The description states the tool provides latitude and longitude for a place via Open-Meteo, which is clear and distinguishes it from weather-hint and timezone siblings. It lacks an explicit verb like 'get' or 'resolve,' 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 phrase 'for a place' implies the tool should be used when an agent needs coordinates of a location. However, it does not state when not to use it, mention prerequisites, or name alternative tools for related 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?

With no annotations, the description carries the full behavioral burden, but it only states the parse action. It does not disclose what happens for invalid or non-GitHub URLs, what the return shape is, or that all parameters except `url` are effectively ignored; the schema hints at discarding, but the tool description itself adds little 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 a single tight sentence with no filler, and the core action is front-loaded. It is efficient and easy to scan, though it sacrifices some contextual 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?

Despite high schema coverage, there is no output schema or annotation, and the input schema contains nine unrelated optional parameters. The description does not explain the expected return value, failure behavior, or why the non-URL parameters exist, leaving an agent to infer key invocation details from the schema 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%, and the schema itself marks every parameter except `url` as discarded, so the description does not need to repeat parameter details. The one-line description adds no extra parameter-level meaning, but the baseline is satisfied by the schema coverage.

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

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

The description states a specific verb ('Parse'), a concrete resource ('owner and repo'), and a clear source ('GitHub URL'). This distinguishes it from sibling shape tools such as figma-url-shape and jira-key-shape without needing to open their schemas.

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 use for GitHub URLs and owner/repo extraction, but it gives no explicit when-to-use or when-not-to-use guidance and names no alternatives among the many sibling tools. Usage context is clear but 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 full burden of behavioral disclosure. It does reveal that the count is for the current front page and that titles are discarded, implying a read-only, count-only operation. However, it does not state the return format, whether a network request is made, or failure behavior, leaving moderate 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 extremely concise and front-loaded: the core operation appears in the first sentence, and the second phrase adds a meaningful output constraint. There is no wasted text or redundant restating of the tool name.

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

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

Given nine optional parameters, no output schema, and no annotations, the description is too thin for reliable invocation. It does not explain whether the tool needs a feed URL, defaults to a built-in HN source, or returns a plain integer vs. a structured response, so an agent may not know how 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 baseline is 3. The schema already documents all nine optional parameters, including the relevant 'feed' parameter as a Public RSS or Atom URL with titles discarded. However, the description adds no parameter-specific guidance and does not tell the agent which parameter, if any, is required 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 a specific operation (count), a specific resource (current Hacker News front-page stories), and an output constraint (titles discarded). This distinguishes it from sibling tools like web-fetch or browser-url-ok, which fetch or validate rather than count.

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

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

There is no guidance about when to prefer this tool over alternatives such as web-fetch or citation, and no mention of prerequisites or exclusions. The only implied use is that an agent might call it when it needs the current HN front-page story count, but this is not made 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?

No annotations are present, so the description carries the full burden of behavioral disclosure. It suggests a read-only list of common timezone names but does not state whether the list is exhaustive, whether it has side effects, what output format is returned, or why the many input parameters are accepted and discarded.

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

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

The description is extremely short and contains no filler or redundant wording. It stays on topic, though the missing verb makes it slightly under-specified rather than optimally 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?

Despite having a small description, the tool has nine optional parameters with unusual discarding semantics and no output schema. The description does not explain what the agent should pass, how inputs affect the result, or what a successful response looks like, so a caller is left with significant ambiguity.

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 every parameter already has a description, so the baseline is 3. The tool description itself adds no parameter semantics and does not connect the 'ref', 'url', 'city', 'feed', 'host', 'json', and 'path' parameters to the concept of IANA timezone names.

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 phrase 'Common IANA timezone names' clearly identifies the resource, and 'for clock calls' suggests the intended use case. However, it lacks an explicit verb such as 'return' or 'list', so the exact operation is left slightly implicit. The name 'iana-zones' helps disambiguate from sibling time-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?

No guidance is provided about when to use this tool versus alternatives like timezone or utc-time. The phrase 'for clock calls' implies a usage context but does not explain prerequisites, exclusions, or when another tool would be preferable.

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

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

The word 'public' hints at a no-auth read operation and 'group counts only' promises a narrow output, but with no annotations the description carries the full burden. It does not disclose failure behavior, what happens when robots.txt is missing, whether parameters are actually used or discarded, or any side effects of the fetch.

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 sentence with no filler, and it front-loads the action and the key output restriction. It is appropriately sized for the little it aims to convey.

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

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

For a tool with no annotations, no output schema, and nine optional parameters, this one-sentence description is insufficient. It lacks parameter mapping, return format, and error semantics, so an agent cannot confidently invoke it correctly despite understanding the general 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?

Although schema coverage is high, the parameter descriptions are largely unrelated to fetching robots.txt, e.g., 'Git ref name; discarded after the shape check' and 'City name for a public weather hint'. The tool description never identifies which of the nine optional parameters should be set for the robots.txt fetch, leaving the mapping 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 action ('Fetch a public robots.txt') and a specific output scope ('return group counts only'), which is enough to distinguish it from generic fetchers like web-fetch. However, it does not say how the target robots.txt is identified or which parameter supplies it, so it is not fully unambiguous.

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

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

There is no guidance about when to prefer this tool over sibling tools or what to use instead for full robots.txt content. Usage context is only implied by the bare action, with no conditions, exclusions, or alternatives 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 full burden of behavioral disclosure. 'Key discarded' usefully signals that the received key is not retained, and 'check' implies a non-mutating operation. However, the description does not say whether the tool returns a boolean, an error, a normalized key, or what exactly constitutes a valid shape.

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 appropriately short and front-loaded with the main action, with no filler sentences. It loses one point because the term 'Key' in the second sentence does not correspond to any schema property, making the concise phrasing slightly misleading.

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 output schema, and no annotations, this description is materially incomplete. It fails to identify the relevant parameter, define the expected Jira key shape, or describe the return value, so an agent cannot reliably invoke the tool.

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

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

Although schema coverage is 100%, the description refers to a 'key' while the input schema contains no key property; it contains ref, url, city, feed, host, json, path, zone, and query. The description therefore adds no usable parameter mapping and actively conflicts with the schema, leaving an agent unable to determine which input to populate.

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 ('Check') and a specific resource ('Jira issue key shape'), which clearly distinguishes it from sibling shape tools like github-repo-shape, domain-shape, or figma-url-shape. The ambiguity about which parameter carries the key is an input-mapping concern, not a purpose clarity concern.

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

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

The use case is implied: use this tool when you need to validate the shape of a Jira issue key. There is no explicit guidance about when not to use it, nor any mention of alternative tools that might be better suited for other key or identifier formats.

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 must carry the behavioral burden. The only disclosed behavior is that the body is discarded; it omits whether this is a HEAD/GET request, redirect handling, timeout behavior, auth needs, or what an error/non-2xx response looks like.

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

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

Two terse sentences, with the main action front-loaded. The 'Body discarded' fragment adds useful output behavior without padding, though it is abrupt and does not compensate for missing context.

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

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

For a 9-parameter, no-output-schema tool with no annotations, this description is under-specified. It addresses one scenario, leaves the role of the other parameters unexplained, and gives no return-format 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 100% description coverage, so the baseline is 3. The tool description adds no parameter-level information and fails to identify which parameter corresponds to the 'public library docs URL' mentioned in the description.

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

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

The description names a concrete operation (returning HTTP status) and a resource ('public library docs URL'), and notes body is discarded. It does not explain which of the nine schema parameters is the URL, nor how it differs from siblings like fetch-status or browser-url-ok, so it stops short of full clarity.

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 fetch-status, web-fetch, browser-url-ok, or normalize-url. No alternatives, exclusions, or context 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 provided, the description carries the full burden. 'Values discarded' usefully signals that values are not retained, but it does not disclose whether it counts top-level keys or nested keys, whether any state is persisted, what happens on invalid JSON, 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 extremely short, front-loaded with the verb and resource, and contains no filler. It is efficient, though arguably too terse to fully support a nine-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?

The tool has no output schema, so the description should explain what the caller will receive; it does not. It also fails to explain how to select among the many input parameters or how values are discarded, leaving an agent unable to reliably invoke the tool correctly.

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

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

Schema description coverage is 100%, so each parameter has some description. However, the tool description does not clarify which of the nine parameters supplies the JSON object or how the unrelated-looking parameters such as ref, url, city, and route map to 'Count keys in a JSON object.' The schema carries most of the parameter burden, but the mapping remains 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 states a specific action and resource: 'Count keys in a JSON object.' This is directly meaningful and distinct from a vague name alone. However, it does not differentiate from sibling tools like validate-json, domain-shape, or hn-front-count, so it is not fully positioned among alternatives.

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

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

There is no guidance about when to use this tool versus alternatives such as validate-json or other shape-related tools. No conditions, exclusions, or contextual hints are provided beyond the basic action.

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 an important transformation (query and fragment are dropped), but it does not state whether the operation is purely local, how invalid URLs are handled, or that all parameters other than url are effectively ignored for normalization. This is partial disclosure, not full transparency.

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

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

The description is a single front-loaded sentence with no filler: it states the return value first and then the key exclusion. Every word earns its place, and it is easy to scan in a tool list.

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

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

For a simple normalizer the description is usable, but with no output schema it does not specify the return shape (e.g., object keys or tuple order) or behavior for invalid/malformed URLs. The nine-parameter schema also raises ambiguity about which inputs are meaningful, and the description does not resolve that.

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

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

Schema description coverage is 100%, so the baseline is 3. The main description adds no parameter-level meaning beyond identifying URL and dropping query/fragment, but the schema's own descriptions document the parameters, albeit with many 'discarded' notes. The description could have helped by explicitly saying only 'url' is used, given the nine-parameter 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 verb ('Return') and resource ('origin, host, and path for a URL') and adds a distinguishing behavior: 'Query and fragment are dropped.' This clearly separates it from sibling URL tools like fetch-status or browser-url-ok, which imply different operations.

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 it: whenever an agent needs a URL reduced to origin, host, and path. However, it gives no explicit when-not-to-use guidance or alternatives, and with 27 sibling tools the agent must infer the boundary from the one-sentence behavior.

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 discloses exactly one behavioral trait ('No browser is launched'), which is valuable given the Playwright name, but it does not explain whether the tool performs an actual network request, what 'can be opened' means (HTTP status, DNS resolution, etc.), what the return value is, or how the many non-URL parameters are handled.

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

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

Two short sentences, front-loaded with the primary action ('Check whether a URL can be opened') followed by a key limitation ('No browser is launched'). Every word earns its place, with no filler or redundancy.

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

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

The tool has a complex seven-parameter schema, no output schema, and many near-sibling tools (browser-url-ok, web-fetch, fetch-status, normalize-url, validate-json). The description only addresses URL checking and does not clarify return semantics, the meaning of 'opened', how the other parameters relate, or how to choose this tool over 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% — each of the seven parameters has a description (e.g., 'Git ref name; discarded after the shape check'). The tool description adds no parameter-level meaning, but the baseline of 3 applies because the schema already documents each parameter.

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

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

The description states a specific verb and resource ('Check whether a URL can be opened') and adds a distinguishing behavioral trait ('No browser is launched') that separates it from browser-based sibling tools. However, it does not explicitly name a sibling or explain how it differs from browser-url-ok, and the broad input schema with city, ref, json, and path parameters is not reflected in the stated purpose.

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

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

The 'No browser is launched' line gives an implied usage context: use this for lightweight URL checks without browser overhead. But there is no explicit when-to-use guidance, no mention of prerequisites, and no exclusions naming alternatives like browser-url-ok or web-fetch.

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

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

With no annotations, the description carries the full disclosure burden, but it only says the query is discarded. It does not state the return type, behavior on empty input, counting semantics, or why parameters like json, url, and ref mention unrelated shape/validation checks.

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, scannable, and front-loaded with the action. It earns its conciseness, though it omits important operational details that a slightly longer description should provide.

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, two sentences are insufficient. An agent cannot determine what to pass, what the return value looks like, or why the schema includes so many unrelated-looking 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?

Although the schema covers all parameters, the descriptions are inconsistent with the tool-level description. Only query is explicitly tied to length checking, while ref, url, json, and others reference unrelated behaviors like shape checks and normalization. The description never explains which parameter should be used as the search query or what the other eight are for.

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 ('Count characters') on a specific resource ('a search query'), and the discarded note signals a stateless check. However, the input schema accepts nine unrelated string parameters and the description does not explain their relationship to the query, muddying the tool's actual 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?

No guidance is given on when to use this tool versus its many siblings. With tools like memory-key-count, validate-json, and multiple shape-check tools present, an agent needs at least a hint about what kind of input warrants calling this tool.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says the tool is a 'short catalog' and does not mention that all nine input parameters are effectively discarded, that no arguments are needed, or what output the agent should 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 only one sentence and easy to skim, which is efficient. However, it is under-specified beyond a label-like phrase, so the brevity borders on insufficient rather than excellently 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?

For a tool with no output schema and no annotations, the description leaves important context missing: how to invoke it, that the parameters are ignored, and what kind of catalog data will be returned. An agent would need to guess or call the tool experimentally to understand its behavior.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description adds no parameter detail. The schema documents each parameter individually, though the description fails to clarify that none of them are relevant to retrieving the status-code catalog.

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

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

The description identifies the resource as a catalog of common HTTP status codes, so an agent can roughly infer what the tool provides. However, it uses a noun phrase rather than a specific action verb and does not explicitly differentiate it from siblings like fetch-status or web-fetch.

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

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

There is no guidance about when to use status-catalog versus related tools such as fetch-status, browser-url-ok, or normalize-url. The description implies a static reference lookup, but it never states the intended invocation context or when an alternative should be preferred.

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 one important trait ('Prompt discarded'), indicating that caller input is ignored. However, it does not clarify whether the template is static, whether all parameters are ignored, or whether there are side effects.

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

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

The description is two short sentences with no filler. The core purpose is front-loaded, and the behavioral warning 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 states the return value and warns that the prompt is ignored, but it does not explain the template's content, confirm that no arguments are needed, or address why some parameters (like url and host) appear non-discarded. With no output schema, this leaves some ambiguity.

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 schema already documents all nine parameters and their discard behavior. The description adds no parameter-level meaning beyond a generic 'Prompt discarded,' which is not tied to any specific schema 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?

The first sentence states a clear verb and resource: 'Return a three-step thinking template.' It is not a tautology and is distinct from the sibling validation/fetch utilities, though it does not explicitly name or contrast any sibling.

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

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

There is no guidance on when to use this tool versus the many sibling tools. 'Prompt discarded' only says input is not used; it does not state use cases, exclusions, or alternatives.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It conveys that this is a read-only time lookup with no obvious side effects, but it does not describe the output format or clarify that the tz value is actually used rather than discarded. Core behavior is clear, but additional transparency is 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?

The description is a single front-loaded sentence with no filler. It communicates the essential operation efficiently and is appropriately sized for a simple lookup 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?

There is no output schema and no annotations, leaving the return format and safety profile implicit. With nine optional parameters in the schema, the description does not explicitly say that only tz is relevant, which introduces some ambiguity. The core purpose is well covered, but the description alone is not fully self-sufficient.

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 the schema already documents the tz parameter as 'IANA zone name'. The description connects that parameter to the tool's purpose by referring to a 'named IANA timezone', making it clear that tz selects the zone for which time is returned. The parameter name is not explicitly repeated, but the mapping is unambiguous.

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 the current time for a named IANA timezone. The phrase 'named IANA timezone' clearly distinguishes it from siblings like utc-time and iana-zones. There is no tautology or 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 implies when to use the tool: when the caller needs the current time in a specific IANA timezone. However, it does not explicitly name alternatives, exclusions, or when-not-to-use conditions, leaving the usage guidance largely 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 explaining behavior, but it only says 'Current UTC timestamp.' It does not disclose that the seven input parameters are optionally accepted and then discarded, that the tool is stateless/read-only, or that calling it requires no arguments. The only behavioral hints appear inside the schema's parameter descriptions, not in the tool description itself.

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?

'Current UTC timestamp.' is a single compact sentence with no filler or redundancy. Every word is relevant, and the core purpose is immediately visible. It is appropriately sized for a minimal utility, even if more context would be useful.

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

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

Given seven optional parameters, no annotations, and no output schema, this description is incomplete. It does not explain whether the agent should pass any of the listed inputs, why they exist, what the timestamp format is, or whether any side effects occur. A richer description would tie the parameters to the tool's shape-check/discard behavior and state that the tool can be called with no arguments.

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 nothing about the seven parameters, but the input schema already documents each one with descriptions including notes like 'discarded after the shape check' and 'no disk access.' With high schema description coverage, the baseline of 3 applies; the description does not need to repeat parameter details, though it could clarify that parameters are optional and irrelevant to the timestamp 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 the tool's output: a current UTC timestamp. This is more specific than the tool name and differentiates it from siblings like timezone, though it lacks an explicit verb like 'returns' or 'gets' and does not mention that the timestamp is the only meaningful output.

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

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

There is no guidance on when to use this tool instead of alternatives like timezone or web-fetch. The description only states what the tool returns, leaving the agent to infer use cases from the name. No exclusions, conditions, or when-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?

No annotations are provided, so the description carries the full burden. It does disclose that the body is discarded, which is a useful side-effect note, but it does not state what the tool returns, how invalid JSON is handled, or whether any validation rules beyond well-formedness apply.

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 purpose and a concise side-effect. There is no filler, though the term 'body' is not explicitly tied to the 'json' parameter, creating slight ambiguity.

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

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

The tool has no output schema and no annotations, so the description needs to explain invocation and expected results more than it does. It never clarifies the return shape or behavior on invalid JSON, and the nine-parameter schema with many irrelevant-looking fields could confuse an agent without more 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 coverage is 100%, so the baseline is 3. The description itself adds no parameter-level meaning, but the input schema already documents 'json' as the text to validate and marks the other fields as discarded.

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

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

The description states a specific action ('Check whether a body is valid JSON') and a clear resource. It doesn't explicitly distinguish itself from sibling validation tools, but the name and phrasing make the JSON-focused purpose evident.

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 validate-json versus alternatives, nor any exclusions. Sibling tools like domain-shape, file-path-ok, or wiki-title-ok roughly fit a validation family, but the description never mentions them or gives 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 disclosure burden, but it only states that Open-Meteo is the data source. It does not disclose network dependence, failure behavior for unknown cities, units of the returned temperature, or the fact that all other schema fields are discarded/ignored. No behavioral traits beyond the basic call are revealed.

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 8-word sentence that front-loads the core function and data source. There is no repetition of the tool name or fluff. It is concise even if it sacrifices 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?

Given the 9-parameter schema and no output schema, the description is minimally adequate: combined with the schema's `city` parameter description, an agent can infer to pass a city and receive a temperature. However, it leaves unspecified units, response shape, and whether non-city inputs are allowed. These gaps are modest for such a simple tool, so it remains usable but not complete.

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

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

Schema description coverage is 100%, so the baseline is 3, and the description adds only a slight signal that `city` is the relevant parameter. It does not specify units, required format, or how to handle the other eight parameters. The schema parameter descriptions already provide most of the needed 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 tool returns current temperature for a city via Open-Meteo, which identifies the result and data source. It is domain-distinct from sibling tools like geo-hint or lib-docs-hint, though it lacks an explicit verb and doesn't mention the `city` 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?

The description offers no guidance about when to prefer this tool over alternatives, no exclusions, and no mention that only the `city` parameter is relevant among the nine available. The intended use case is implied by the name and description but not explicitly stated, leaving an agent without routing context when sibling hint tools exist.

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 a meaningful behavioral trait: 'Body discarded.' This goes beyond what the schema states and is useful safety-relevant context. However, with no annotations and no output schema, it does not mention redirects, failure behavior, network side effects, or how non-URL parameters 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 exceptionally concise and front-loaded, with every word contributing. It earns high marks for efficiency, though the brevity omits enough context to be considered a model structural example.

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

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

Given eight heterogeneous parameters, no annotations, no output schema, and several close sibling tools, a single sentence about HTTP status and content type is insufficient. Missing guidance about input selection, return shape, and tool differentiation makes misuse likely.

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 each parameter individually, so the coverage is high and the description need not restate them. But the description does not clarify the relationship between the 'public URL' operation and the many alternative parameters such as ref, city, json, and path, leaving the agent uncertain about which parameter is the intended primary input.

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

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

The description clearly states a specific operation: retrieving HTTP status and content type for a public URL, and it adds that the body is discarded. It does not, however, differentiate itself from sibling tools such as fetch-status or normalize-url, and the schema's many non-URL parameters make the exact scope slightly fuzzy.

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 web-fetch versus alternatives like fetch-status, browser-url-ok, or normalize-url. The only implicit cue is 'public URL,' which is not sufficient for an agent to decide among the closely related sibling tools.

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

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

Annotations are empty, so the description carries the burden. It adds one useful behavioral detail in 'Title discarded after the call', but it does not disclose network behavior, error cases, or the shape of the result. No contradiction with the annotations.

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 purpose and followed by a concise retention note. There is no filler or 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?

With no output schema, the description should at least imply the return value clearly and show how to supply the title. It does neither, and the disconnect between the description and the input schema leaves an agent unable to invoke the tool reliably.

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?

While the input schema has roughly 100% parameter descriptions, the description refers to a 'title' that is not present as a schema property. The actual properties (ref, url, city, feed, host, json, path) appear unrelated to a Wikipedia title check, so the description misleads rather than adds meaningful parameter semantics.

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

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

The description states a concrete action and resource: 'Check whether a Wikipedia title exists.' This is clear and specific enough to convey the tool's core job. However, it does not distinguish itself from sibling validation tools such as validate-json or browser-url-ok, so it does not earn a 5.

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

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

The description provides no guidance about when to use this tool versus alternatives, no context, and no exclusions. With many similar-looking sibling tools, an agent is given no routing cues to choose this one.

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