Teaspoons to milliliters

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

With no annotations, the description must carry the full behavioral burden. It discloses that it returns setup files and remote MCP hops, and notes that task text is discarded. However, it does not state whether the tool performs external calls, requires authentication, is read-only, or has side effects. It also does not explain error behavior or what 'Task text' refers to precisely. This is a significant gap for a tool that may access remote resources.

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 sentences with no filler. The primary purpose is front-loaded in the first sentence, followed by the output contents and a behavioral note. It is concise and well structured. The only minor issue is that 'Task text discarded' is a bit cryptic and could be clarified, but overall it is 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?

The tool has 9 optional parameters but no output schema and no annotations. The description states what it returns but does not explain how parameters map to the result, which parameters are needed for a typical call, or any constraints or usage patterns. Given the complexity and lack of structured metadata, the description is insufficient for an agent to confidently invoke the tool with the right parameters.

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 is already documented in the schema. The tool description adds no extra meaning about parameters, such as which ones are commonly used together or how they influence the output. According to the rubric, with high coverage the baseline is 3, and the description neither enhances nor detracts from parameter understanding.

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

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

The description clearly states a specific verb ('Find') and a specific resource ('public pay-per-call tool gateway (Monid)'), and enumerates the returned items (CLI setup, how-it-works, skill file, remote MCP hops). This distinguishes it from sibling tools, which are about URL checks, calculations, or shape validation. No ambiguity or tautology.

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 does not state prerequisites, conditions for selection, or situations where it should be avoided. The only behavioral note ('Task text discarded') is not about usage context. With 28 siblings, explicit routing would be valuable but is entirely absent.

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

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

With no annotations, the description carries the full burden. It discloses 'No browser is launched' but does not explain what the tool actually does instead (e.g., network request, format validation, or shape check). The schema repeatedly mentions 'discarded after the shape check,' implying a broader shape-checking behavior, but the description only mentions URL openability, which is misleading.

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 but under-specified. It lacks structure and does not front-load the most important information (e.g., that this is a multi-parameter shape checker). It is not concise in a helpful way; it is just incomplete.

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

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

Given the tool has 9 optional parameters, no output schema, and 28 siblings, the description is severely incomplete. It does not explain what the tool does with non-URL parameters, what the return value is, or how it differs from siblings. An agent cannot reliably 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?

The schema descriptions are informative and cover 100% of parameters, providing clear semantics for each (e.g., 'discarded after the shape check', 'no disk access'). The tool description adds no additional meaning about how these parameters interact with the stated purpose, so it stays at the baseline of 3.

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

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

The description states a specific action ('Check whether a URL can be opened') but the schema includes 8 other parameters (ref, city, feed, json, path, zone, query) that have nothing to do with URLs. This makes the actual scope of the tool ambiguous. It also fails to differentiate from siblings like playwright-url-ok or fetch-status, which also deal with 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?

No guidance is given on when to use this tool versus alternatives. The description provides no conditions, exclusions, or references to sibling tools. An agent has no basis to choose this over playwright-url-ok or fetch-status for a URL check.

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 is the only behavioral disclosure. It states 'Expression discarded' but does not explain what the tool actually does with the parameters, what it returns, or any side effects. The phrase 'a+b style arithmetic' is inconsistent with the schema, so it misleads rather than clarifies.

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, so it is brief, but it is not concise because it contains misleading information. It is not front-loaded with accurate core purpose.

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

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

For a tool with 9 parameters and no output schema, the description is grossly incomplete. It fails to explain what the tool actually does, what the return value is, or how the parameters are used. The description's claim of arithmetic is irrelevant to the actual schema, leaving an agent with no reliable basis 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 coverage is 100% and each parameter has a description (e.g., 'discarded after the shape check'), which gives some meaning. However, the tool description mentions arithmetic, which is unrelated to any parameter. The description adds no value beyond the schema and actively contradicts the parameter set.

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 the tool evaluates 'a+b style arithmetic', but the input schema has no arithmetic expression parameter – instead it lists 9 unrelated string parameters (ref, url, city, feed, etc.). This is misleading; the purpose is not what it claims.

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 any of the 29 siblings. There are no alternatives mentioned, no conditions, and no exclusions.

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 a meaningful side-effect note. However, it doesn't mention whether the tool makes network requests, handles redirects, or any error/edge-case behavior. This is minimal but not entirely absent.

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 exactly two sentences with no fluff. It front-loads the primary purpose and adds a single clarifying note. Every word earns its place, making it appropriately concise and 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 description is incomplete for a tool with 9 parameters. It only explains behavior for URLs, but the schema includes parameters like 'city', 'zone', 'json', and 'feed' that are not addressed. There is no output schema, so the return format is unspecified. An agent would be unclear on what the tool actually does with these other inputs, making the description insufficient for correct invocation.

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

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

Schema description coverage is 100%, so all 9 parameters have descriptions in the schema. The tool description itself adds no extra meaning to the parameters, which is acceptable per the baseline rule. The description does not explain how the many non-URL parameters relate to the stated purpose, but the schema already documents each one.

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') and resource ('host, scheme, and HTTP status for a URL'), which clearly identifies the core purpose. The note that page content is not stored helps distinguish it from content-fetching tools. However, the tool's schema includes many non-URL parameters, so the description doesn't convey the full scope of the tool's functionality.

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 sibling tools like fetch-status or normalize-url. It doesn't mention any specific conditions or alternative tools, leaving the agent to infer usage from the schema 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 provided, the description carries the full burden of behavioral disclosure. It only states 'No identifiers are retained,' a privacy guarantee, but does not disclose whether the tool performs reads, writes, network calls, or any side effects. The schema hints at 'discarded' data, but the description itself does not clarify the tool's runtime behavior or 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 short, but this is under-specification rather than effective conciseness. It contains only a vague purpose and a privacy note, omitting essential details about behavior and usage. The single sentence does not earn its place because it communicates almost nothing actionable.

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

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

With 9 parameters, no output schema, and no annotations, the description is severely incomplete. It gives no information about expected return values, error conditions, or how the parameters interact. An agent cannot correctly invoke this tool based on the description alone; it is essentially a black box.

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, but the description adds nothing beyond the schema. The schema entries like 'Git ref name; discarded after the shape check' are themselves terse and do not explain how the parameter contributes to 'classification.' The description does not bridge the gap, leaving the role of each parameter in the tool's operation unexplained.

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 'Show how this request is classified' is vague: it names no specific verb-object pair, no classification scheme, and no resource. It does not differentiate from siblings like domain-shape or url-ok, which are specific about what they check. The name 'compatibility' hints at a broader purpose, but the description leaves the actual function opaque.

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 any sibling. No mention of prerequisites, alternatives, or conditions that would make this the right choice. The description simply states an action without context, leaving an agent to guess when 'compatibility' is appropriate.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that WHOIS and ownership data are not included, which is a negative constraint, but it does not disclose side effects, return format, or what happens with the various input parameters. For a tool with no annotations and a broad schema, 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 a single sentence, which is efficient in terms of word count and is front-loaded with the primary action. However, it is so short that it under-specifies the tool's behavior. It is concise but not appropriately sized for the complexity of the tool, so a 3 is appropriate.

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

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

The tool has 9 optional parameters, no output schema, and no annotations, making it relatively complex. The description covers only one narrow behavior (hostname splitting) and does not explain how the other parameters are handled, what the tool returns, or what side effects (if any) occur. This is inadequate for an agent to use the tool correctly across its parameter space.

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

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

Schema description coverage is 100%, so all 9 parameters have individual descriptions in the schema. The tool description adds no additional meaning about the parameters; it only mentions hostname splitting, which relates to the 'host' parameter. Since the schema already documents each parameter, the baseline is 3, and the description provides no extra value.

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 'Split' and the resource 'hostname', and adds a constraint 'without WHOIS or ownership data', which conveys a specific scope. However, it does not differentiate from sibling tools like normalize-url or browser-url-ok, and the input schema includes many unrelated parameters, suggesting the description may not cover the full tool scope. It is not a tautology, so it earns a 4.

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. It does not mention conditions, prerequisites, or exclusions. With 28 sibling tools, an agent would have no reason to select this one based on the 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 must carry the behavioral disclosure burden. It does disclose the operation (HEAD) and that only status is returned, implying a read-only, non-destructive action. However, it doesn't mention that other parameters are ignored or discarded, nor does it describe edge cases like redirects or error handling. It's transparent about the core behavior but lacks depth.

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 that efficiently states the action and result. It is concise with no wasted words. However, given the tool's complexity (9 optional parameters, many siblings), the brevity omits crucial context, so while it's concise, it's under-structured for effective selection.

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 severely incomplete for this tool's context. It has 9 parameters, many sibling tools with overlapping functions, no annotations, and no output schema. It fails to explain what 'status' entails, how to choose between this and web-fetch or URL-checking tools, and what happens with the non-URL parameters. An agent would struggle to use this correctly without further 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 description coverage is 100%, so the schema already documents all 9 parameters, including that most are discarded after checks. The description adds no parameter-specific meaning beyond what the schema provides; it only mentions 'public URL' which mirrors the url parameter description. Baseline 3 for high coverage is appropriate.

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

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

The description states a specific verb (HEAD) and resource (URL) and says it returns status only. It clearly indicates the tool performs a read-only HEAD request, distinguishing it from content-fetching tools like web-fetch. However, it does not explicitly differentiate from sibling tools like browser-url-ok or playwright-url-ok, which also check URLs, so it's clear but not fully discriminating.

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 the many sibling tools. It doesn't state any exclusions or recommend alternatives, leaving the agent to infer usage from the name and one-line description. This is a significant gap given the large sibling set.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions that the path is discarded, which is a minor behavior, but it does not state whether the tool performs any side effects (e.g., network access), what it returns on success or failure, or whether it is read-only. For a parsing tool, one might assume no side effects, but that is not explicit. The schema hints that several parameters are 'discarded after the shape check', but the description does not consolidate this.

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. It front-loads the core action, which is good. However, the brevity comes at the cost of essential context (output, usage, parameter relevance). It is not verbose, but it is under-specified to the point of being unhelpful for an agent.

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's complexity—9 optional parameters, no required ones, no output schema, and no annotations—the description is severely incomplete. It does not explain what the tool returns, which parameters to provide, or how to handle the many unrelated schema fields. An agent cannot reliably call this tool based on the description alone; it would need to inspect the schema and guess. The description fails to bridge the gap between the stated purpose and the broad parameter set.

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 meaning to the parameters. The schema provides descriptions for all 9 parameters, but they are largely unrelated to Figma URLs (e.g., 'city', 'feed', 'json'). Only 'url' appears relevant, but the description does not specify that 'url' is the primary parameter or how the others factor in. With 100% schema coverage, the schema already documents each parameter, but the description fails to clarify the intended usage or which parameters are essential for this tool.

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

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

The description states a specific action: 'Parse a Figma file URL' and notes that the path is discarded. This clearly identifies the tool's function and distinguishes it from siblings like 'browser-url-ok' (which checks URL availability) and 'normalize-url' (which normalizes URLs). However, it does not clarify what 'parse' returns (e.g., extracted components or a validity flag), 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?

No guidance is provided on when to use this tool versus alternatives. The description does not mention any conditions, prerequisites, or exclusions. Sibling tools like 'domain-shape' and 'github-repo-shape' exist, but there is no indication of what makes this tool the right choice for a Figma URL specifically. The agent is left to infer usage from the name alone.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It adds 'No disk access,' which is useful, but it doesn't disclose what happens with the other parameters (e.g., they are discarded), error behavior, or return format. This is a significant gap for a tool with 9 optional parameters.

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

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

The description is a single concise sentence, but it is under-specified. It is not overly verbose, yet the content is too thin to be effective. It is structurally fine but does not earn its place by adding necessary 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?

Given 9 parameters and no output schema, the description is highly incomplete. It doesn't explain what 'safe' means, how the tool validates the other inputs, what it returns, or any error handling. An agent would be guessing at the tool's behavior beyond 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 each parameter already has a description in the schema. The tool description adds no parameter-specific meaning beyond that, so it appropriately relies on the schema. Baseline 3 is correct.

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') but the schema includes 8 other parameters (url, city, feed, host, json, zone, query, ref) that are unrelated to path checking. This mismatch makes the tool's actual scope unclear and fails to distinguish it from siblings like browser-url-ok or fetch-status.

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

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

No guidance is provided on when to use this tool versus the many siblings. There are no mentions of alternatives, prerequisites, or conditions that would route an agent here.

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

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

With no annotations, the description must disclose behavior, but it only says 'via Open-Meteo', implying a network call. It does not clarify that most parameters are discarded, whether the operation is read-only, what happens on failure, or what the response format is. The description fails to convey the tool's true behavior beyond the geocoding use case.

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 fluff, but it is under-specified. It lacks any structural cues about usage, parameter priority, or edge cases. Brevity is not conciseness when essential information is omitted.

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

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

The tool has 9 parameters, no output schema, and no annotations, yet the description covers only the geocoding aspect. It provides no explanation of the validation/discard behavior for the other parameters, making it impossible for an agent to understand the tool's full contract. 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 coverage is 100% with per-parameter descriptions, but the tool description adds no semantic value to parameters. It does not indicate which parameter (e.g., city) should be used for the lat/long lookup, nor does it clarify the role of the many 'discarded' parameters. The description leaves parameter selection entirely to the schema, which is confusing due to the unrelated fields.

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

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

The description states 'Latitude and longitude for a place via Open-Meteo', which is a specific purpose, but it contradicts the input schema that includes many unrelated parameters (ref, url, json, etc.) described as 'discarded after the shape check'. This misalignment makes the tool's actual purpose ambiguous and fails to differentiate it from siblings like 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 on when to use this tool versus alternatives such as weather-hint, timezone, or iana-zones. The description does not mention any conditions or exclusions, leaving the agent to guess when this tool is appropriate.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states what it parses but does not explain what happens with invalid URLs, whether other parameters are ignored, what the return format is (no output schema), or any side effects. The description is insufficient to predict behavior beyond the most basic case.

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

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

The description is a single, efficient sentence that front-loads the core purpose. It contains no filler, but it is so terse that it sacrifices necessary detail. For a tool with 9 parameters, this brevity is arguably under-specification rather than ideal 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 the tool has 9 parameters, no output schema, and no annotations, the description is incomplete. It does not explain what the tool returns, how to handle the non-url parameters, error behavior, or any prerequisites. An agent would have to probe or guess to use 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' parameter is for parsing owner/repo, which the schema does not say (schema describes it as 'normalize or cite'). However, it does not clarify the role of the other eight parameters or whether they are ignored, leaving 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 clearly states a specific verb (parse) and resource (GitHub URL) with an explicit output (owner and repo). It distinguishes this tool from sibling shape-checkers like domain-shape and figma-url-shape, which target different URL formats. The purpose is unambiguous and directly actionable.

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

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

No guidance is given on when to use this tool versus alternatives. It does not mention when not to use it, what conditions select it, or any exclusions. An agent must infer from the name and description that it is appropriate only for GitHub URLs.

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

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

With no annotations, the description must disclose behavior. It states that titles are discarded, which is a behavior, but it does not explain what the tool returns (e.g., a count), whether it fetches live data, or why the 9 input parameters are present. The parameter descriptions are generic and unrelated to the tool's purpose, creating confusion.

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

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

The description is concise, consisting of two short sentences. The primary action is front-loaded, and there is no redundant wording. However, it is so brief that it omits crucial information about parameters and output.

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

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

Given the tool has 9 optional parameters and no output schema or annotations, the description is severely incomplete. It does not clarify what the parameters do, what the return value looks like, or any edge cases. An agent cannot confidently invoke this tool correctly based on the description 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 coverage is 100% because all parameters have descriptions, but those descriptions are generic and do not relate to counting HN stories. They describe shape checks and discarding, which suggests a mismatch. The description of the tool does not explain how any of these parameters influence the count, so the schema adds little value for this tool's 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 clearly states the primary action: counting current Hacker News front-page stories. It is specific and distinguishes the tool from siblings since no other tool mentions HN. However, it does not mention the input parameters, leaving some ambiguity about how the tool is invoked.

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

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

There is no guidance on when to use this tool versus alternatives. No conditions, use cases, or exclusions are provided. The description does not mention when to prefer it over other tools like 'web-fetch' or 'fetch-status'.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether the tool is read-only, what it returns, whether it has side effects, or any other runtime behavior. This is a critical gap for a tool with no structured metadata.

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 and extremely terse, but under-specification is not the same as conciseness. It omits essential information, making it inadequate rather than efficiently brief.

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 parameters, no annotations, and no output schema, the description is severely incomplete. It fails to explain what the tool returns, how to use parameters, or any constraints. An agent cannot reliably determine how to call or interpret results from this description 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?

While schema coverage is 100%, the description adds no parameter-level meaning. Moreover, the schema's parameters (ref, url, city, feed, host, json, path, zone, query) appear largely unrelated to the stated purpose of 'IANA timezone names', creating confusion about how to invoke the tool. The description does not connect parameters to the tool's function.

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

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

The description 'Common IANA timezone names for clock calls' is a noun phrase without a clear verb or action. It implies a resource or list but does not state what the tool actually does (e.g., returns, lists, validates). It also fails to differentiate from sibling tools like 'timezone' or 'utc-time', which likely perform time-related 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?

There is no guidance on when to use this tool versus alternatives. No mention of preferred contexts, exclusions, or relationships to siblings. The agent is left to infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions that only group counts are returned, which is a useful constraint, but it omits critical details such as error handling, rate limits, authentication requirements, or the fact that most input parameters are 'discarded after the shape check' (per the schema). The mismatch between the single-purpose description and the broad, mostly-discarded parameter list is not addressed.

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, which is concise, but it is under-specified rather than appropriately sized. It omits essential information about how to specify the target and what the input parameters mean, so it does not earn its place by enabling correct use.

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

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

Given the tool has 9 optional parameters, many of which are discarded, and no output schema, the description is completely inadequate. It fails to explain which parameter is required for the core action, what 'group counts' means, or how failures are surfaced. An agent cannot reliably invoke this tool based on the provided 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?

The schema descriptions are comprehensive (100% coverage) but they are individually vague (e.g., 'HTTPS URL to normalize or cite') and do not connect to the stated action of fetching robots.txt. The tool description adds no parameter semantics whatsoever—it never indicates which parameter (e.g., 'url' or 'host') actually drives the robots.txt fetch. This leaves the agent guessing at how to invoke the tool correctly.

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 ('Fetch a public robots.txt') and a specific result ('return group counts only'), which is clear at a high level. However, it does not clarify which of the nine parameters (e.g., 'url', 'host') should be used to specify the target robots.txt, creating ambiguity. It also does not differentiate from siblings like web-fetch or fetch-status, leaving the agent without a clear selection signal.

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

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

There is no guidance on when to use this tool versus alternatives. No exclusions, prerequisites, or comparisons to sibling tools are provided, so an agent must infer the appropriate usage from the vague 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?

The description discloses that the key is discarded after the check, which is a behavioral trait. However, with no annotations provided, the description carries the full burden. It does not mention whether the tool makes network calls, what happens with other parameters, or what the return value is. It is minimal.

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

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

The description is extremely concise, two sentences, and front-loads the purpose. Each sentence carries information. However, it is under-specified, which is not a conciseness issue but a completeness issue.

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

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

With 9 parameters, no annotations, and no output schema, the description is severely incomplete. It does not explain the return value, the expected format of the key, or how the parameters relate to the check. An agent cannot confidently invoke this tool correctly.

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

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

Schema coverage is 100%, so baseline is 3. However, the description adds no information about the parameters, and the schema itself is confusing because none of the parameter names match 'key'. The description does not clarify which parameter should contain the Jira key, leaving the agent to guess. This reduces the score below 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?

States a specific verb and resource: 'Check a Jira issue key shape.' This distinguishes it from sibling shape-checkers like domain-shape or github-repo-shape. However, the input schema includes many unrelated parameters, so the stated purpose is not clearly reflected in the schema, which could confuse an agent about what input to provide. So it is clear but not perfectly aligned.

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

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

No guidance on when to use this tool versus alternatives. The description does not mention any conditions, alternatives, or exclusions. The implied usage is when you need to validate a Jira issue key, but it is not stated explicitly.

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 full responsibility for behavioral disclosure. It only mentions 'Body discarded' and implies an HTTP status fetch, but says nothing about side effects, permission requirements, or how the varied parameters are handled. This is insufficient for a tool with no safety 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?

The description is one short sentence, which is concise in word count but grossly under-specified. It lacks the detail needed to be useful; it is not 'appropriately sized' but rather an incomplete fragment.

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?

A 9-parameter tool with no output schema, no annotations, and no meaningful description is completely inadequate. The description fails to explain the role of most parameters, the output format, or any operational context, leaving an agent with no way 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?

The schema provides 100% parameter descriptions, so the baseline is 3. The description adds no parameter-specific meaning, neither reinforcing nor contradicting the schema. It simply does not mention 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 'HTTP status for a public library docs URL' but the input schema accepts 9 diverse parameters (ref, city, json, path, zone, query, etc.) that do not align with that narrow purpose. It lacks a clear verb-resource structure and does not distinguish itself from sibling URL-checking tools like fetch-status or browser-url-ok.

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

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

There is no guidance on when to use this tool versus its many siblings. No mention of prerequisites, exclusions, or alternative tools, leaving the agent to guess based on the misleading title.

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

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

With no annotations provided, the description must fully disclose behavioral traits. It mentions 'Values discarded,' which is a behavioral note, but it does not state whether the operation is read-only, side-effect free, or what the return format is. This is insufficient for a tool with zero annotation coverage.

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 sentences and front-loaded with the core purpose. It is appropriately concise but sacrifices necessary detail about input and output, which affects 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?

The tool has 9 optional parameters, no required ones, and no output schema. The description does not explain how to pass a JSON object, nor does it describe the return value or any constraints. The mismatch between the stated purpose and the actual schema makes this definition incomplete for an agent to invoke correctly.

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

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

The schema has 100% description coverage, so each parameter is documented. However, the tool description adds no meaning to these parameters, and they appear unrelated to the stated purpose of counting keys in a JSON object (e.g., ref, city, zone). The description fails to bridge the gap between the flat parameters and the tool's core function, so the baseline of 3 is retained.

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 (count) and resource (keys in a JSON object), which distinguishes it from siblings like validate-json. However, it does not explain how the JSON object is provided, given the flat schema of 9 string parameters, leaving ambiguity about the actual input format.

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 alternatives. The description does not mention any context, prerequisites, or exclusions, leaving the agent without direction on appropriate usage.

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 query and fragment are dropped, which is a concrete behavioral trait, but it says nothing about error handling, input validation (e.g., what happens for non-HTTPS URLs), or why the schema includes many other parameters that appear unrelated to URL normalization. The mismatch between description and schema is unexplained.

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

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

The description is a single concise sentence, which is efficient, but it is under-specified for a tool with nine parameters. The brevity does not compensate for the lack of information about the additional parameters or the tool's behavior beyond the basic URL transformation.

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 complexity (9 parameters, none required, no output schema), the description is incomplete. It does not explain the role of each parameter, how to choose which to provide, or what the return value looks like beyond listing three fields. The mismatch between the description's narrow focus and the schema's breadth leaves critical gaps for an agent.

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, but the tool description only indirectly addresses the 'url' parameter. It provides no meaning for 'ref', 'city', 'json', 'zone', or other parameters, and does not clarify whether they are ignored or influence the output. This leaves an agent unable to decide which parameters to populate or what the tool expects.

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 origin, host, and path for a URL and drops query/fragment. This distinguishes it from sibling tools like web-fetch or fetch-status. However, the input schema exposes nine unrelated parameters (city, json, zone, etc.), and the description gives no hint that they are irrelevant or that the tool ignores them, creating ambiguity about the true scope.

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

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

There is no guidance on when to use this tool versus alternatives such as browser-url-ok or fetch-status. The description does not mention prerequisites, limitations, or conditions that would direct an agent to this tool over others. An agent would have to infer usage from the name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does state 'No browser is launched,' which is a useful behavioral note, but it does not mention whether network access occurs, what the return value is, side effects, or any error handling. For a tool named after Playwright, the clarification is helpful, but overall behavioral transparency is minimal.

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

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

The description is a single, front-loaded sentence that states the core action and a key caveat. It is efficient with no wasted words. However, it is perhaps too terse, leaving out essential context, so it does not earn a 5 for completeness of structure, but it is appropriately concise.

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

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

The tool has 9 parameters, no output schema, and no annotations, yet the description is only one sentence. It does not explain how to use the parameters, what the tool returns, when it succeeds or fails, or any behavioral details beyond the no-browser note. An agent would be largely unguided for this multi-parameter tool.

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

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

Schema coverage is 100% and each parameter has a description, so the schema already provides meaning. The tool description adds no additional context about how the parameters relate to the primary action of checking a URL. Given the high schema coverage, a baseline of 3 is appropriate; the description does not enhance parameter understanding, but it does not need to.

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 ('Check') and resource ('whether a URL can be opened'), and adds a key behavioral note ('No browser is launched'). However, the tool's name and the nine unrelated parameters (city, json, path, etc.) create confusion about what exactly is checked. The purpose is not tightly distinguished from siblings like browser-url-ok, and the description does not clarify the 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?

There is no guidance on when to use this tool versus alternatives such as browser-url-ok or normalize-url. The description gives no context for when this check is appropriate, no exclusions, and no mention of prerequisites. An agent would have to infer usage from the name and the parameters, which are ambiguous.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states 'Query discarded,' which is a minor side-effect note. It does not reveal that the tool likely ignores all parameters except 'query', whether it performs any network/disk access, what it returns, or any failure modes. This is insufficient for a tool with 9 parameters.

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

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

The description is two short sentences with zero wasted words. It front-loads the purpose and includes a behavioral note ('Query discarded'). It is appropriately concise for a simple tool.

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

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

The tool has 9 optional parameters, no output schema, and no annotations. The description is severely incomplete: it doesn't specify the return value (presumably the character count), doesn't explain the role of the other 8 parameters, doesn't mention any side effects beyond discarding the query, and provides no error handling or usage context. This is far below what an agent needs 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 coverage is 100%, and every parameter already has a description. The tool description adds no parameter-level meaning beyond what the schema provides. It doesn't clarify which parameter is the search query (though the 'query' field is obvious) or how the other parameters are treated. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description states a specific verb ('Count') and resource ('characters in a search query'), which clearly identifies the tool's core function. However, it does not differentiate from sibling counting tools like memory-key-count or hn-front-count, and it doesn't clarify that only the 'query' parameter is relevant given the schema's many other 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?

There is no guidance on when to use this tool versus alternatives. The description does not mention when it is appropriate to call it, when not to, or suggest any sibling tools for comparison. An agent would have no idea whether this is the right tool for a given counting task.

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, and the description gives no behavioral details. It does not disclose that many parameters are 'discarded' (as hinted in schema descriptions), nor what the tool actually does with them. The single sentence conveys no behavior beyond a vague catalog reference.

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

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

The description is concise (one short sentence), but conciseness is undermined by under-specification. It earns a 3 because it is not bloated, but it lacks the substance needed for a tool with 9 parameters.

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

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

For a tool with 9 optional parameters and no output schema, a one-sentence description is wholly inadequate. The agent cannot know what inputs to pass, what the tool returns, or how the parameters relate to status codes. This is severely 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 coverage is 100%, so the baseline is 3, but the description adds zero parameter context. Worse, the parameter descriptions (e.g., 'Git ref name; discarded after the shape check') are disjoint from the stated purpose, creating confusion rather than clarification. The description does not compensate for this.

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 purpose: a catalog of HTTP status codes. However, it does not explain how the nine optional parameters (ref, url, city, etc.) relate to that purpose. The description is not a tautology, but the mismatch between name/purpose and parameters is confusing.

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 siblings like fetch-status or normalize-url. It does not mention any conditions, prerequisites, or alternatives, leaving the agent to infer when a 'catalog of status codes' is needed.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It reveals nothing about side effects, permissions, what happens to the inputs, or the nature of the returned template. 'Prompt discarded' hints at input handling but is ambiguous and does not explain behavior for each parameter. This is a severe transparency gap.

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

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

The description is extremely short, which might seem concise, but it fails to convey essential information. The two sentences do not earn their place because they are vague and do not clarify the tool's function. It is under-specified rather than effectively 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?

With 9 parameters, no output schema, and no annotations, the description is grossly incomplete. It does not explain what the template contains, how parameters are used (beyond vague 'discarded' hints), or what the agent should expect. An agent cannot reliably invoke this tool correctly based on the description 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 coverage is 100%, with each parameter individually described (e.g., 'discarded after the shape check'). The tool description itself adds no parameter-specific meaning, but the schema already documents all parameters adequately. Per the baseline for high coverage, a score of 3 is appropriate.

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

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

The description states a verb ('Return') and a resource ('three-step thinking template'), but it is vague about what this template actually is or how it relates to the tool's name and the 9 input parameters. It does not clearly distinguish the tool from siblings like calc-eval or geo-hint, which have more concrete purposes. 'Prompt discarded' adds confusion rather than 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 on when to use this tool versus any of the 27 siblings. No context, conditions, or exclusions are provided. The description does not mislead, but it offers zero help for an agent deciding whether 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 provided, the description carries the full burden of behavioral disclosure. It fails to mention that only the 'zone' parameter is relevant and that the other eight parameters in the schema are ignored. This is misleading because an agent might fill in unrelated fields, thinking they affect the result. It also omits any side-effect or error 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 concise sentence with no filler. However, it is not front-loaded with any practical guidance; it only states the purpose without helping the agent understand how to use the tool effectively. It is appropriately sized for a simple tool but lacks the structure needed to compensate for the complex schema.

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

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

The tool is simple in function but the schema exposes nine parameters, most of which are unrelated. The description does not clarify which parameter to use or that others are discarded. With no output schema and no annotations, the agent has no way to know what to expect or how to properly invoke it. This is incomplete for a tool with such a noisy 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?

Although schema description coverage is 100%, the description adds no value beyond the schema. It mentions 'named IANA timezone' but does not explicitly map that to the 'zone' parameter. More importantly, it does not clarify that the other eight parameters are irrelevant, leaving the agent to guess which ones to supply. This is a significant gap given the large number of 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 clear verb ('current time') and a resource ('named IANA timezone'), which distinguishes it from the sibling 'utc-time' (which presumably gives UTC). However, it does not explicitly differentiate itself from other siblings like 'iana-zones' (which likely lists zones) or mention that it only needs a zone name, so it is not fully self-contained.

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

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

There is no guidance on when to use this tool versus alternatives. The description only states what it does, with no mention of when to prefer it over 'utc-time' or other time-related tools. The context signals show many sibling tools, but no exclusions or conditions are given.

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, but it fails entirely. It does not state any side effects, requirements, or limitations, and the provided description is factually inconsistent with the parameter list. An agent cannot infer what the tool actually does or what it returns.

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

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

The description is extremely short, but this is not conciseness—it is under-specification. It offers a single phrase that is both incomplete and misleading. The lack of any structural elements (e.g., examples, conditions) makes it unhelpful, and the brevity does not compensate for the absence of substantive 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?

Given that the tool has 9 parameters, no output schema, and no annotations, the description is grossly inadequate. The description does not explain the relationship between the parameters and the intended conversion, nor does it clarify the return format. The tool is effectively unusable by an agent without additional 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?

While the schema itself provides descriptions for each of the 9 parameters, these descriptions are completely disconnected from the tool's stated purpose. The description adds no meaning beyond the schema, and the parameters appear to belong to a different tool altogether. The agent is left with no understanding of how to use these parameters for a teaspoon-to-milliliter conversion.

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 'Teaspoons to milliliters' implies a unit conversion, but the input schema contains unrelated parameters such as 'ref', 'url', 'city', 'json', and 'host'. There is no mention of volume or units anywhere. The description is actively misleading and does not reflect the tool's actual function, making it impossible for an agent to select it correctly.

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 or how it relates to its 28 siblings. The description gives no context for selection, and the mismatched schema only worsens the confusion. There is no distinction from other tools like 'domain-shape' or 'geo-hint'.

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, and it provides none. It does not state the timestamp format (epoch vs ISO), whether parameters are truly ignored (the schema hints they are 'discarded', but the description is silent), or that this is a side-effect-free read. The schema's 'discarded after' hints live in structured data, not the description.

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 is genuinely concise, but this is under-specification rather than efficiency. For a tool with 9 parameters and no annotations, a single clause leaves nearly everything unexplained; it earns its place but is far too sparse to 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?

With 9 parameters, no annotations, and no output schema, the description is grossly incomplete. It does not explain why the parameters exist, what the return value looks like, or what the tool is for beyond the bare phrase. An agent lacks enough context to call it confidently or to decide it is the right tool.

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

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

Schema coverage is 100%, giving a baseline of 3, but the description adds nothing to explain why a UTC-time tool accepts a Git ref, city name, RSS feed, or JSON text as parameters. An agent cannot tell whether supplying these alters behavior or is pointless; the description fails to clarify that they appear to be no-ops. This confusion actively misleads invocation.

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

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

The description 'Current UTC timestamp.' states a clear, specific purpose (a verb/resource pair) that is not a tautology. However, it does nothing to distinguish itself from the sibling 'timezone' tool, and the 9-parameter schema (git ref, city, URL, host...) bears no obvious relation to retrieving the current time, leaving the tool's true scope ambiguous.

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

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

No guidance whatsoever on when to use this tool versus its siblings (timezone, calc-eval). With a 'timezone' sibling available, an agent gets no hint about whether utc-time is for the raw current time while timezone handles conversions, nor any 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 provided, so the description carries full behavioral disclosure burden. It only states 'The body is discarded,' which is a limited side-effect note. It does not mention that the tool is read-only, whether network/disk access is involved (though schema notes 'no disk access' for path), or any other operational characteristics. This is insufficient for a tool with no annotation safety net.

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 (two sentences) and front-loads the purpose, which is good. However, it omits essential context for a tool with 9 parameters, making it under-specified rather than concise. A few more sentences explaining parameter usage and differentiation would justify a higher score.

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

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

Given the tool has 9 optional parameters, no annotations, and no output schema, the description is severely incomplete. It does not explain why the other seven parameters are present, how they interact with the JSON validation, or what the expected input format is. The description alone is wholly inadequate for an agent to correctly invoke this tool.

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

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

Schema description coverage is 100%, so the baseline is 3. However, the description adds no value beyond the schema and actually introduces an undefined term 'body' that does not match any parameter. It fails to clarify which parameter holds the JSON (json vs path) or why the other seven parameters exist. The schema already documents each parameter, but the description should at least map the primary input, which it does not.

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+resource: 'Check whether a body is valid JSON.' However, it uses 'body' without mapping to any schema parameter (likely 'json' or 'path'), which is ambiguous. It also doesn't differentiate from sibling shape-check tools like domain-shape or github-repo-shape, leaving the agent to infer the 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 alternatives. With 28 sibling tools, many of which validate shapes of specific inputs, the description provides no exclusions or conditions for selection. The agent is left to guess when validate-json is appropriate.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only states the purpose and omits any mention of side effects, external calls, error handling, or the read-only nature of the operation. The schema hints that many parameters are discarded, but the description does not clarify this. This is a significant gap for a tool that presumably makes an external API call.

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

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

The description is a single, focused sentence with no filler. It is front-loaded with the core purpose and is appropriately concise for a tool that performs a simple action. Every word contributes to understanding.

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

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

Given the tool has 9 parameters but only one is relevant, and there is no output schema, the description is incomplete. It does not guide the agent on which parameters to supply, which are ignored, or what the response looks like. The lack of guidance increases the risk of misuse, especially with many sibling hint tools available. More context is needed for correct invocation.

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

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

Schema description coverage is 100%, so the schema documents all parameters. The description adds minimal value beyond the schema, only implicitly indicating that 'city' is the relevant parameter. Since the schema already explains each parameter's role, the description does not need to repeat it, but it also does not enrich the semantics. A baseline of 3 is appropriate.

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

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

The description states a clear purpose: get current temperature for a city via Open-Meteo. It is specific about the resource (city) and the action (getting temperature). It does not explicitly differentiate from sibling tools like geo-hint, but the weather focus is distinct enough that an agent can infer it. A score of 4 reflects that it is clear but does not explicitly name alternatives.

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

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

The description gives no guidance on when to use this tool versus other hint tools. It does not mention that only the 'city' parameter is relevant, nor does it indicate that other parameters are discarded. There are no exclusions or conditions for when to prefer this tool over siblings like geo-hint or lib-docs-hint.

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 bears full responsibility for behavioral disclosure. It only states that the body is discarded, but does not explain what happens with the other parameters (ref, city, feed, etc.) or any side effects, error handling, or security considerations. The behavior beyond the basic fetch is opaque.

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

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

The description is a single, concise sentence that front-loads the primary function and includes a key behavioral detail (body discarded). It has no wasted words, but its brevity may come at the cost of necessary context, making it slightly under-specified for a tool with many parameters.

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 parameters and no output schema, the description is severely incomplete. It does not explain how the parameters are used, what the return value looks like, or how they align with the stated purpose of checking HTTP status. An agent would lack the information needed to correctly invoke this tool in a real scenario.

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

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

Schema coverage is 100% and each parameter has a descriptive label, so the schema already provides substantial meaning. The tool description adds no additional context about how these parameters relate to the core fetch operation or which ones are primary, so it does not improve on the baseline set by the schema.

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

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

The description clearly states the core function: retrieving HTTP status and content type for a public URL, with the body discarded. However, it does not differentiate from siblings like fetch-status or browser-url-ok, and it omits any mention of the other eight parameters, which could confuse an agent about the tool's full 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?

There is no guidance on when to use this tool versus the many similar siblings (e.g., fetch-status, normalize-url, browser-url-ok). No conditions, exclusions, or alternative references are provided, leaving the agent to guess which tool fits a given scenario.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It only states that the title is discarded after the call, which implies no persistence. However, it does not disclose whether the tool makes network requests, requires authentication, or has side effects. The schema descriptions also mention 'discarded' for many fields, but these are generic and do not clarify the tool's overall 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 (one sentence), which is concise, but it lacks structure and essential information. It does not front-load critical details or explain the tool's workflow. The brevity is under-specification rather than effective conciseness.

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

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

For a tool with 9 optional parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain the purpose of each parameter, how they contribute to the title check, what the tool returns, or any error conditions. An agent would be unable to invoke this tool correctly based on the description 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 coverage is 100%, so every parameter has a description, but these descriptions are misleading in the context of the tool. For example, 'ref' says 'Git ref name; discarded after the shape check' – this has nothing to do with checking a Wikipedia title. The tool description adds no clarification about how parameters relate to the tool's purpose. An agent cannot infer which parameter, if any, holds the title to 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 specific purpose: 'Check whether a Wikipedia title exists.' This is a clear verb and resource, but it does not map to any of the 9 input parameters (none are named 'title' or obviously represent a Wikipedia title). The schema is filled with unrelated fields (ref, url, city, feed, etc.), so an agent cannot determine how to provide the title. It also does not differentiate from sibling tools that might check URLs or fetch pages.

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. There is no mention of prerequisites, exclusions, or related sibling tools. An agent has no context to decide between this and similar checking tools like browser-url-ok or fetch-status.

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