ISO country MC

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

With no annotations, the description carries the transparency burden. It does disclose that task text is discarded and describes the return content, which is helpful. However, it never states that all input parameters are effectively ignored, and some schema parameter descriptions appear to suggest real processing, muddying the behavioral picture.

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

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

The description is very short and front-loaded, with no filler. Each sentence adds distinct information: what the tool finds, what it returns, and the behavioral note about discarded task text.

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

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

For a tool with nine optional parameters, no output schema, no annotations, and many siblings operating on those exact parameter types, this description is incomplete. It never explains why the schema contains URL/feed/zone/query/json/path parameters or that they can be safely omitted, leaving an agent vulnerable to misusing this tool as a general-purpose URL, timezone, or JSON utility.

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

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

Schema description coverage is 100%, so the schema already documents each parameter individually. The main description adds only the general 'Task text discarded' note, which does not meaningfully clarify the role of the nine unrelated parameters. Baseline 3 is appropriate given the high schema coverage.

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

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

The description clearly states the verb and resource: 'Find a public pay-per-call tool gateway (Monid)' and lists the returned artifacts. It does not explicitly differentiate itself from the 27 sibling tools, but the stated purpose is specific enough to be recognizable.

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

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

The intended context—needing information about the Monid gateway—is implied but never made explicit as a when-to-use/when-not-to-use rule. Because the schema accepts URL, JSON, timezone, query, and other parameters that match many sibling tools, there is significant risk of using this tool for the wrong task without clearer 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 no browser is launched, but it fails to say whether this tool performs a network request, whether it is purely syntactic, or what side effects, if any, occur. The schema's mention that many parameters are discarded is helpful, but the description itself remains opaque about the actual behavior.

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

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

The description is very short and front-loaded, with no filler words or redundant restatements. It loses a point because it is arguably too terse for a tool with nine varied parameters and no output schema, but the prose itself is efficient.

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 of nine parameters, no annotations, and no output schema, the description is incomplete. It does not explain what "can be opened" means, what the tool returns, or how it relates to the many sibling shape/check tools. An agent would still need to infer much of the tool's intended behavior.

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

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

Schema coverage is 100%, so the baseline is 3; each parameter is individually documented. However, the description adds no framing for why the tool accepts ref, city, feed, json, path, and query parameters when its stated purpose is only about URLs, and it does not help the agent understand the relationships between the 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 clearly states the action (check whether a URL can be opened) and adds a meaningful behavioral qualifier ("No browser is launched"). However, it does not explicitly distinguish itself from sibling tools like playwright-url-ok, fetch-status, or normalized-url, leaving some ambiguity about which tool to use.

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 such as normalize-url, fetch-status, or playwright-url-ok. It also does not mention exclusions, prerequisites, or conditions for choosing this tool over siblings.

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

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

With no annotations, the description carries the full burden of explaining side effects and return behavior. It only says the expression is discarded, which is a useful statelessness hint, but it does not say whether a numeric result is returned, how errors are reported, or what happens to the other supplied 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 very short and front-loaded, with no filler. It is too sparse to be fully effective, and the second clause is ambiguous because no schema parameter is named as the expression.

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

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

This tool has no annotations, no output schema, nine heterogeneous optional parameters, and a description that mentions an operand absent from the schema. An agent cannot correctly select or invoke this tool from the provided definition.

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

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

Schema coverage of the existing parameters is 100%, giving a baseline of 3, but the description introduces an 'expression' operand that does not exist in the schema. It neither maps 'a+b' to any parameter nor clarifies the roles of ref/url/city/feed/host/json/path/query, so it actively undermines 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 names a concrete action and operand style ('Evaluate a+b style arithmetic'), so it is not a pure tautology. But it never connects that action to any of the nine schema parameters, all of which are non-arithmetic strings, leaving an agent unable to determine what input actually gets evaluated. It also gives no hints that separate calc-eval from sibling shape-check or fetch tools.

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

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

There is no guidance about when to choose calc-eval over any sibling, no preconditions, and no example call. 'Expression discarded' is an after-the-fact behavior, not guidance.

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

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

No annotations are present, so the description carries the full behavioral disclosure burden. It does disclose one meaningful privacy trait—'Page content is not stored'—but it does not explain that the tool likely performs a network request, how failures or redirects are handled, what happens with the numerous other accepted parameters, or any rate-limit/auth concerns. This is insufficient for an HTTP-facing tool.

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

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

The description is two short sentences, front-loads the main purpose, and adds one genuinely useful behavioral note about content not being stored. Every sentence earns its place, and there is no redundant restating of the tool name or 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?

Given the tool has a complex nine-parameter schema, no output schema, no annotations, and many similar sibling tools, this description is too thin. It does not explain return value structure, error behavior, which parameters should actually be supplied, or how this tool differs from fetch-status or normalize-url. An agent would struggle to invoke it reliably outside a narrow URL-status case.

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 effectively 100%, with each parameter having a description, so the baseline is 3. The tool description adds little beyond identifying URL as the relevant input; it does not clarify the roles of the other decoy parameters or the inconsistent host/path descriptions. Since the schema already documents each parameter, the description is not required to restate them, but it also does not compensate for the overall confusion.

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

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

The description states a specific action and result: 'Return host, scheme, and HTTP status for a URL.' This clearly identifies the resource and the output fields, and the added note that page content is not stored helps separate it from general fetch tools. However, it does not reconcile the tool name 'citation' with the many unrelated schema parameters, so some ambiguity remains.

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, normalize-url, web-fetch, or browser-url-ok. The description implies URL checking/citation but does not state conditions, exclusions, or alternatives. An agent must infer the appropriate context from the name and 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?

There are no annotations, so the description carries the full behavioral disclosure burden. It does mention a privacy trait ('No identifiers are retained'), which adds some context, but it does not disclose whether the operation is read-only, what it computes, what it returns, or any side effects. This is thinner than the update_drive example that scored 2.

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

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

The description is very concise: two short sentences with no filler. The privacy statement earns some place, and the purpose statement is front-loaded. However, it is so underspecified that the compactness reflects omission rather than helpful organization, so it does not merit a 5.

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

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

Given a 9-parameter tool with no annotations and no output schema, the description is far from complete. It gives no indication of what classification categories exist, what the output looks like, which parameters are meaningful for which use, or any example invocation. The agent cannot confidently invoke this tool correctly from the provided 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 description coverage is 100%, so the baseline is 3 even without parameter information in the description. The description does not add any meaning beyond the schema, but the schema already documents all nine parameters, including discard behavior. The description's 'No identifiers are retained' loosely echoes the schema's 'discarded' notes without adding new semantic 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 states a verb and object: 'Show how this request is classified.' However, it is vague about what 'classified' means and does not identify what kind of classification result is produced. It does not distinguish this tool from the many shape-check siblings like domain-shape, validate-json, or file-path-ok.

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

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

No usage guidance is provided. The description does not say when to use this tool over alternatives, what inputs are appropriate, or what conditions select this tool. The sibling list shows many possibly related checks, but the description gives no basis for choosing among them.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only mentions that WHOIS/ownership data is not used and says nothing about output format, side effects, network access, or whether inputs are discarded. The schema hints at discard behavior, but the description itself is minimal.

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

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

The description is one short, front-loaded sentence with no padding. The qualifier about WHOIS/ownership is useful scope but is not connected to any alternative tool, so it is efficient but not maximally informative.

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

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

For a tool with 9 optional parameters, no output schema, and no annotations, this one-sentence description is severely incomplete. It does not state which parameter is the intended input, what the returned labels or format look like, or why unrelated fields are accepted. An agent cannot reliably invoke it without guessing.

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

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

Schema description coverage is 100%, so the baseline is 3; the schema already documents each parameter, including discard behavior. The description adds nothing about how to choose among host, url, json, path, etc., and its exclusive focus on hostname leaves the other parameters 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 states a specific verb and resource: split a hostname into labels, and it explicitly scopes out WHOIS/ownership data. This is not a tautology and aligns with the tool name. However, it does not account for the many non-hostname parameters in the schema, so the stated purpose is narrower than the input surface.

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 instead of siblings such as normalize-url, validate-json, or github-repo-shape. The only exclusion is 'without WHOIS or ownership data,' but it names no alternative and no trigger condition.

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

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

With no annotations, the description must carry behavioral disclosure. It does reveal the HTTP method (HEAD) and the output scope (status only), but it hides the fact that many schema parameters are accepted and then discarded after various shape checks. There is no mention of what statuses are returned, redirects, or side effects, leaving a 9-parameter tool mostly 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 short sentence with the key verb and object front-loaded; there is no filler. It loses a point because the brevity is achieved by omitting the tool's actual multi-input behavior, so the conciseness comes at the cost of usefulness.

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

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

For a tool with 9 optional parameters, no output schema, and no annotations, this description is not complete enough. It documents only the URL mode and gives no guidance for the other modes hinted at by the schema (JSON validation, timezone, city, path, search length). An agent cannot confidently invoke the tool for non-URL inputs based on 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?

Schema description coverage is 100%, so the baseline is 3 and the heavy lifting is done by the schema. The description itself adds no parameter semantics beyond naming 'URL', and it silently ignores the other eight parameters. It neither conflicts with nor meaningfully enhances the schema.

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

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

The description names a specific operation (HEAD a public URL) and a narrow return value (status only), so it reads clearly on its face. However, the input schema advertises eight unrelated entity types (city, json, path, zone, query, etc.) that are 'discarded' or checked, which the one-line description does not account for. This makes the stated purpose incomplete and potentially misleading for any non-URL call.

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

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

There is no guidance about when to call fetch-status versus siblings like browser-url-ok, web-fetch, or playwright-url-ok. No alternatives, conditions, or exclusions are mentioned, so the agent must infer selection solely from the ambiguous name.

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, but it only states 'Path discarded' and gives no details about whether this is a pure local parse, what happens to the URL, what output is produced, or any side effects. The behavior is minimally implied but not meaningfully disclosed.

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

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

The description is compact and front-loaded: the primary action comes first, and 'Path discarded' is a short, meaningful qualifier. It does not waste words, though the brevity contributes to under-specification in 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?

For a tool with 9 parameters, no required parameters, no output schema, and no annotations, this description is far too thin. It does not explain how to pass the Figma URL, what a valid Figma URL shape is, what the tool returns, or how it relates to sibling URL tools.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds the Figma-specific context missing from the generic `url` parameter description, but it still does not explicitly identify which of the 9 parameters carries the Figma URL, leaving the agent to infer `url` from the tool name.

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

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

The description names a specific action, 'Parse a Figma file URL', which clearly identifies the tool's resource and distinguishes it from sibling shape tools like github-repo-shape or jira-key-shape. The additional 'Path discarded' provides useful scope, though it does not explicitly say what the parse result is.

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

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

No guidance is given about when to choose this tool over alternatives such as normalize-url, browser-url-ok, or file-path-ok. The Figma mention implies the intended use case, but explicit conditions, exclusions, or alternative routing are 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 must carry behavioral disclosure, and it does say 'No disk access,' which is a meaningful safety-related boundary. However, it does not explain what 'safe' means, what the tool returns, or whether there are any other side effects.

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

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

The description is only two short sentences with no filler. The core action is front-loaded, and the 'No disk access' clarification earns its place by setting an important expectation.

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

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

For a tool with no annotations, no output schema, and nine input parameters, the description is too sparse. It does not state the return value, the notion of path safety, or how the additional schema parameters relate to the purpose, leaving the agent to infer too much.

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

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

The input schema already provides descriptions for all parameters, so the baseline is 3. The description adds no extra parameter-level meaning, and it does not clarify why unrelated-looking parameters such as url, city, feed, and json are present in a path-checking 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 clear action and target: 'Check whether a path looks safe' identifies this as a file-path validation tool. It is distinct enough from the title and gives a concrete purpose, but it does not explicitly differentiate itself from related sibling tools such as browser-url-ok or wiki-title-ok.

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

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

There is no guidance about when to use this tool versus alternatives like browser-url-ok, playwright-url-ok, or normalize-url. 'No disk access' is a useful hint, but it is not framed as a selection criterion or exclusion rule.

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 behavioral burden. It discloses the core behavior: an Open-Meteo lookup producing latitude and longitude. It does not state that the operation is read-only, how unknown places are handled, or the exact return structure, but the core external-call behavior is visible.

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 with the key output and source front-loaded. There is no filler or redundant restatement of the tool name.

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

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

The tool has no annotations, no output schema, and a 9-parameter optional schema. A correct invocation depends on knowing that `city` is the relevant input and what the returned coordinates look like. The description provides neither, so an agent facing many optional fields would struggle 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?

All nine parameters have schema descriptions, giving full coverage and a baseline of 3. The description adds no parameter-level guidance and does not connect 'a place' to the `city` parameter, while several schema fields are clearly unrelated to geo-hint, creating mild 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 indicates the tool returns latitude and longitude for a place and names the external source (Open-Meteo), which distinguishes it from weather or timezone siblings. However, it is a noun phrase rather than an explicit action statement and does not name the input parameter that represents the place.

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

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

There is no guidance about when to use this tool versus siblings like weather-hint, timezone, or other shape-check tools. The description does not mention expected inputs, exclusions, or alternative tools, leaving selection entirely to inference.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure, but it only states the parse intent. It does not say whether the tool is read-only, whether it validates the URL, what happens for invalid input, whether it accesses the network, or whether all other schema parameters are ignored.

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

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

The description is a single front-loaded sentence with no filler. Every word earns its place, and the core extraction behavior is stated immediately.

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

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

This is an extraction tool with no output schema and no annotations, so the description should explain the return format and edge-case behavior, but it does not. With nine optional parameters and no mention of which one activates the tool, the description leaves the agent to infer the call pattern and expected result.

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

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

Schema coverage is already 100%, so the baseline is 3, but the description adds meaningful semantics by clarifying that the 'url' parameter is a GitHub URL and that the result should be owner/repo. This is especially valuable because the schema's url description—'HTTPS URL to normalize or cite'—does not convey the GitHub-specific intent.

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

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

The description names a specific verb ('parse'), a specific input ('a GitHub URL') and a specific output ('owner and repo'), which clearly distinguishes this tool from sibling shape tools like figma-url-shape or jira-key-shape. It is a clear, non-tautological statement of purpose.

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

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

The description gives no explicit when-to-use guidance and names no alternatives or exclusions. An agent can only infer from the tool name and wording that this is for GitHub URLs, but the description does not help it choose between this tool and related URL/shape tools like normalize-url or domain-shape.

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 disclosure burden. 'Titles discarded' is a genuine behavioral trait — it tells the agent the response contains counts, not title content. But nothing is disclosed about network behavior, rate limits on the HN feed, how a custom feed URL alters the operation, or failure modes.

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

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

Two short sentences with zero filler; the verb comes first and each word earns its place. 'Titles discarded' efficiently doubles as a behavioral disclosure and a hint about return semantics. This is exemplary front-loading.

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

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

Despite having 9 parameters, no output schema, and no annotations, the description is only 8 substantive words. It never explains which parameters the tool actually consumes (only 'feed' plausibly matters) or how the return value is shaped. An agent would be left guessing whether to pass a feed URL, rely on a default HN fetch, or ignore the unrelated params like 'city' and 'zone'.

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 of 3 applies; every one of the 9 parameters is individually described. The tool description adds no parameter meaning beyond the schema, and it even creates a slight mismatch by saying 'Hacker News front-page' while the 'feed' parameter describes a generic public RSS/Atom URL.

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

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

The description states a specific verb and resource: 'Count current Hacker News front-page stories,' which clearly distinguishes it from fetch/check siblings like web-fetch, fetch-status, and inspect-robots. The 'Titles discarded' sentence adds a concrete scope qualifier. However, the schema's 'feed' parameter accepts any 'Public RSS or Atom URL,' creating ambiguity about whether the tool is HN-specific or a generic feed counter.

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 names no sibling tool and states no conditions or exclusions, such as preferring this over web-fetch for a quick count. Usage context must be entirely inferred from the single purpose sentence.

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 explaining behavior. It does not disclose whether this is a read-only lookup, a validation, a listing with pagination, or anything else. The description provides essentially no behavioral detail.

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

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

The description is a single short sentence and is easy to scan. It is not bloated, though it earns only partial credit because its brevity leaves the tool under-specified.

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, no output schema, and no behavioral disclosure, the description is far too thin for an agent to know how to invoke the tool correctly. It does not explain what input matters, what output to expect, or how it relates to the sibling tools.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the tool description adds no parameter meaning. However, several parameters (ref, url, feed, json, path) appear unrelated to IANA timezone names, and the description does nothing to clarify how they connect to the 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 identifies the resource as 'Common IANA timezone names' and gives a context ('for clock calls'), but it lacks a verb and never states what the tool does with these names—whether it lists, validates, or returns them. It is more than a pure tautology but remains vague about the actual operation.

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

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

The phrase 'for clock calls' weakly implies a usage context, but there is no guidance about when to choose this tool over the sibling timezone or utc-time tools. No alternatives, exclusions, or prerequisites are mentioned.

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

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

No annotations are provided, so the description carries the full behavioral burden. It confirms a read-only network fetch and constrains the return to 'group counts only', but it does not explain parsing behavior, error handling, timeout or rate-limit behavior, or what happens for missing or non-robots.txt URLs.

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

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

The description is a single front-loaded sentence with no filler: verb, target, and output limit all appear immediately. The terseness is a completeness problem, not a conciseness problem.

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

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

With no output schema, no annotations, 9 optional parameters, and a large sibling list, this description is too thin. It does not define what 'group counts' means, what the return value looks like, or how the many 'discarded' parameters relate to the robots.txt fetch.

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 a baseline of 3 applies even though the description itself adds no parameter-level meaning. However, the description never connects its 'robots.txt' behavior to the schema's many generic parameters, and several parameters (ref, city, feed, json, path) appear unrelated to fetching a robots.txt.

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

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

The description states the action ('Fetch'), the target resource ('public robots.txt'), and the output restriction ('group counts only'), so the core purpose is clear. It does not explicitly say which parameter carries the robots.txt URL, but the intent is unambiguous enough to distinguish it from generic fetch tools.

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

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

No guidance is given about when to use this tool versus siblings like web-fetch, fetch-status, or normalize-url. The description also does not say whether to pass a URL, host, or something else, nor does it define what counts as 'public'.

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 discloses that the 'key' is discarded, but does not explain whether the check is local-only, whether the key is the only input used, what side effects occur, or what result is returned. The disclosure is vague and does not match any explicit schema parameter.

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

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

The description is short, but brevity here is under-specification rather than conciseness. The two sentences do not earn their place because they omit the critical information needed to invoke the tool correctly, and the 'Key discarded' phrase is disconnected from the schema.

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

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

For a tool with nine parameters, no output schema, and no annotations, a two-sentence description that fails to identify the relevant input or describe the return behavior is severely incomplete. It is not possible for an agent to know what to pass, what a valid shape is, or what the tool returns.

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%, which normally yields a baseline of 3, but the description provides no mapping from its 'key' concept to any of the nine schema properties. The schema properties (ref, url, city, feed, host, json, path, zone, query) are unrelated to a Jira issue key, so an agent cannot determine which parameter to populate. The description fails to compensate for this mismatch.

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 restates the tool name ('jira-key-shape' → 'Check a Jira issue key shape') without adding substantive meaning. It says what resource is checked but not what 'shape' means, what a valid key looks like, or which schema parameter carries the key. 'Key discarded' is a behavioral note, not a clarification of purpose.

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

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

No guidance is given about when to prefer this tool over its many sibling shape-checking tools, such as github-repo-shape, domain-shape, or figma-url-shape. The description only implies a use case from the name; it does not state prerequisites, exclusions, or alternatives.

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

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

With no annotations, the description carries the transparency burden. It does disclose the return kind ('HTTP status') and the body handling ('Body discarded'), but it omits other behavioral details such as redirects, error handling, auth, rate limits, and behavior for non-library-docs URLs.

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

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

The description is two short sentences with no filler. The core purpose is front-loaded and each sentence earns its place.

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

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

The tool has 9 optional parameters and no output schema, yet the description doesn't say which parameter to pass or what output structure to expect. It also leaves the relationship between the 'public library docs URL' purpose and the many unrelated schema fields unexplained, so an agent must guess how to invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already documents each parameter and the description adds no additional parameter-level meaning. Some schema entries explicitly say values are 'discarded after the shape check', which weakens their semantic value but does not create a contradiction.

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

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

The description states a specific operation ('HTTP status') and resource ('public library docs URL'), and adds the key body-discarded behavior. It is clear enough to distinguish the tool from generic fetch tools, though it doesn't explicitly contrast with siblings.

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

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

The phrase 'Body discarded' implicitly tells an agent to use this tool when only the HTTP status is needed and not the response body. However, it doesn't name alternatives like fetch-status or web-fetch, and it gives no explicit when-to-use or when-not-to-use guidance.

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

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

With no annotations provided, the description carries the full burden of behavior disclosure. 'Values discarded' is a meaningful behavioral trait: it tells the agent that parameter values are irrelevant and only key presence matters. It does not explain the output format or whether counting is recursive, but it does disclose the key behavioral quirk.

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

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

The description is two short sentences with no filler. 'Count keys in a JSON object' is front-loaded, and 'Values discarded' is a concise, high-value behavioral qualifier.

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

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

The description is adequate for a simple counting operation, but the lack of an output schema and the presence of many unrelated-looking parameters leave some ambiguity about whether the input object is the argument object itself or a JSON string supplied via a parameter. No annotations help close that 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%, so the baseline is 3, but the description adds important global semantics: despite the nine heterogeneous parameters, their values are all discarded. This helps an agent avoid being misled by the individual parameter descriptions and focus on key presence instead.

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 operation: count keys in a JSON object, and adds a distinctive detail: values are discarded. It is specific and useful, but it does not explicitly differentiate this tool from siblings such as validate-json or other shape-related tools.

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

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

The description implies when to use the tool: whenever you need the number of keys in a JSON object. It does not provide explicit when-not-to-use guidance or name alternatives, so the usage context is only implied.

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

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

With no annotations, the description carries the behavioral burden. It discloses one meaningful behavior: query and fragment are dropped, and it implies a non-destructive read/normalize operation. But it does not reveal that other schema parameters are discarded/ignored, what happens with no arguments, or what the output shape is, which is a significant gap for a 9-parameter tool.

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

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

Two short, front-loaded sentences with no filler. The key output contract is stated first, and the scoping rule (query/fragment dropped) follows immediately.

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

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

This description is too thin for the surrounding context: no annotations, no output schema, nine optional parameters, and a large family of sibling tools. An agent is not told which parameter to populate, why the other fields exist, what the return representation is, or how to choose this tool over related siblings.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds URL-processing semantics (dropping query/fragment) beyond the schema's 'HTTPS URL to normalize or cite', but it does not clarify whether the other eight optional parameters are ever relevant or how the promised output maps onto the input fields named host and path.

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 is a specific, verb-led statement: it returns origin, host, and path for a URL, and it states that query and fragment are dropped. This is enough to distinguish it from fetch/checking siblings like web-fetch or browser-url-ok, though it never names an alternative. It also does not explain why the schema contains many unrelated optional fields.

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

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

The description implies usage when an agent needs URL component extraction rather than URL validation or fetching, so there is some contextual signal. However, it gives no explicit when-not-to-use instructions and no guidance among the many nearby sibling tools such as domain-shape, browser-url-ok, or web-fetch.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that no browser is launched, which is useful, but it does not say whether the tool performs a network request, follows redirects, requires authentication, or what side effects or errors may occur. The meaning of 'can be opened' is left ambiguous.

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

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

The description is short and front-loaded, with no filler words. The second sentence adds a relevant caveat, but the overall terseness leaves out enough context that it feels slightly under-specified rather than optimally concise.

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

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

Despite having nine parameters, no output schema, and no annotations, the description only covers a narrow aspect of the tool. It does not explain return values, which parameters are relevant, how to interpret results, or how this tool differs from closely related siblings. An agent would likely need additional information to invoke it confidently.

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

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

Schema description coverage is 100%, so the structured schema already documents all nine parameters. The description adds no parameter-level detail, but none is required beyond the baseline given the complete 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?

States a specific action ('check whether a URL can be opened') and a useful qualifier ('No browser is launched'). It is clear about the resource, though it does not precisely define what 'can be opened' means or differentiate itself from sibling tools 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?

The 'No browser is launched' sentence implies a browserless URL-check use case, but the description gives no explicit when-to-use guidance, no exclusions, and no named alternatives. An agent must infer the intended distinction from the sibling tool names.

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 disclose one useful trait, 'Query discarded,' establishing a read-only, no-retention operation, which is genuine value beyond the name. However, it never states the return value (does it return the numeric length or a confirmation?), how counting treats empty or non-ASCII input, or error behavior, so the disclosure is only partial.

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

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

The description is two short sentences with zero filler, and the core action is front-loaded before the behavioral note. It is efficient and every word earns its place, though the extreme brevity for a tool with nine parameters and no annotations verges on under-specification, which keeps it from a top score.

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

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

For a 9-parameter tool with no annotations and no output schema, a two-sentence description is incomplete: it never explains why the tool accepts a URL, city, timezone, JSON text, and file path alongside the search text, nor what the call returns or how it relates to the sibling shape/check tools. An agent reading the description alone cannot reliably determine the input contract or the output, so the tool depends entirely on the schema descriptions to be usable.

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 of the nine parameters already has a textual description (e.g., 'Search text; discarded after the length check'), which sets the baseline at 3. The tool description adds no parameter-level meaning beyond restating 'search query,' which maps directly to the already-documented query parameter. No compensation for a coverage gap is needed because none exists.

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

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

The first sentence states a specific operation, 'Count characters in a search query,' with a clear verb and resource, and the tool name aligns with it. It doesn't explicitly differentiate from sibling count/shape tools such as memory-key-count or hn-front-count, and the 9-parameter schema (ref, url, city, feed, host, json, path, zone, query) muddies which input is the actual subject, so it stops short of a 5.

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

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

The description offers no guidance on when to invoke this tool rather than a sibling such as memory-key-count, hn-front-count, or the various shape/check tools. There is no mention of conditions, alternatives, or the fact that the schema accepts nine different domain-specific inputs, leaving the agent to infer the usage context entirely. A sentence like 'use when you need the character length of search text' would close this gap.

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 implies the tool is a passive reference ('catalog') and that the catalog is limited to common codes ('short'). It says nothing about side effects, network calls, auth, rate limits, or what the tool returns, and its only hint at discard behavior lives in the schema descriptions, not the tool 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?

The description is seven words in a single sentence with zero filler, and the key subject ('HTTP status codes') is front-loaded. Every word earns its place; there is no redundancy. The brevity veers into under-specification, but that penalty belongs to contextual completeness rather than 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 nine parameters, no annotations, and no output schema, a single fragment is inadequate. The description neither explains how an agent should invoke it to get a status code nor describes the return value, and the parameter set appears entirely disconnected from the stated purpose. An agent cannot determine from this definition how to call the tool correctly or what it will receive back.

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

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

Schema coverage is 100% — all nine parameters have descriptions — so the baseline of 3 applies. But the tool description adds zero parameter semantics: it never explains how ref, url, city, feed, host, json, or path relate to a catalog of HTTP status codes. The schema documents each parameter individually, yet neither the schema nor the description establishes a coherent link between those inputs and the tool's stated purpose.

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

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

The description names the resource domain (HTTP status codes) with more specificity than the bare name 'status-catalog', which could ambiguously imply git status, server status, or tool status. However, it is a noun phrase with no verb — it doesn't say whether the tool looks up a code, lists all codes, or maps inputs to codes. None of the nine parameters (ref, url, city, feed, host, json, path) obviously connect to querying an HTTP status code, and it does nothing to distinguish itself from the sibling 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?

There is zero guidance on when to use this tool. It mentions no conditions, no use cases, and no exclusions, and it never names alternatives — despite fetch-status being a natural point of confusion in the sibling list. An agent has nothing to route on.

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 behavioral burden. It does disclose a non-obvious trait: 'Prompt discarded.' However, it does not say whether any of the nine schema parameters are used or ignored, nor what the returned template looks like or whether the operation has side effects, so transparency is partial.

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

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

The description is two short sentences, front-loaded with the main action and followed by a behavioral warning. There is no filler or redundant content, though the terseness does contribute to ambiguity in other dimensions.

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

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

Given nine optional parameters, no output schema, no annotations, and no usage context, this two-sentence description is not sufficient. An agent cannot confidently determine which parameter to pass, whether parameters affect the output, or what the 'three-step thinking template' actually returns.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the tool description adds no parameter-level meaning. The description never connects the nine parameters to the template, but the schema already documents each parameter individually, so the description is not required to repeat that information.

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

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

The description states a concrete action and output: 'Return a three-step thinking template.' However, it does not explain what the template actually contains or how it relates to the nine unrelated optional parameters, leaving the purpose somewhat vague. It also does not differentiate this tool from the many sibling shape-check and hint tools.

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

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

No guidance is given about when to use this tool versus any sibling tool, and no exclusions or alternatives are mentioned. 'Prompt discarded' hints that the tool will not process the prompt, but it does not clarify when an agent should choose this tool or what input, if any, 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 behavioral burden. 'Current time' communicates a read-only operation, but the description does not disclose return format, timezone validity handling, or the surprising disconnect between the stated purpose and the unrelated schema parameters. It is not contradictory, but it leaves clear gaps.

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

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

The description is a single, tightly worded sentence with no filler. The core function and scope are front-loaded, making it highly concise and readable.

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

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

For a tool with nine optional parameters and no output schema, a one-line description is inadequate. There is no connection between the timezone purpose and the supplied parameters, no return-value description, and no guidance on valid IANA names or sibling fallbacks, so an agent cannot reliably invoke the tool.

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

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

Although schema parameter descriptions exist, none of them represents an IANA timezone input. The description's 'named IANA timezone' maps to no property, and the schema exposes a grab-bag of unrelated optional fields such as ref, url, city, feed, host, json, and path. This actively misleads parameter selection.

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

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

The phrase 'Current time in a named IANA timezone' clearly identifies the resource and scope of the tool, and implies a read-only lookup. It does not explicitly name or contrast sibling tools such as utc-time or iana-zones, so it misses the highest tier of purpose 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?

No guidance is given on when to use this tool versus utc-time or iana-zones, how to obtain a valid IANA timezone name, or what inputs are actually required. The only implied signal is that a 'named IANA timezone' is needed, but the schema does not expose such a parameter.

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, but it only says 'Current UTC timestamp.' It does not disclose that the tool accepts a broad set of inputs (ref, url, city, feed, host, json, path) that appear unrelated to the output, nor does it clarify whether those values are ignored, validated, or used in any way. This is a notable gap for a tool whose schema suggests significant but unexplained behavior.

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

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

The description is a single, front-loaded sentence with zero wasted words. It communicates the core purpose immediately and avoids any redundant elaboration.

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

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

Despite appearing simple, the tool’s input schema is large and orthogonal to the described output. The description does not explain how the parameters relate to the timestamp, what the return format is, or whether parameters are ignored, making the definition incomplete for correct invocation. No output schema or annotations compensate for these gaps.

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

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

The input schema provides detailed descriptions for all seven parameters, so schema coverage is effectively 100%, giving a baseline of 3. The description itself adds no parameter-level meaning and, in fact, creates confusion because the listed parameters (Git ref, URL, city, feed, host, JSON, path) do not obviously relate to a UTC timestamp operation.

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

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

The description clearly states that the tool returns the current UTC timestamp, which identifies both the resource and the action. However, it does not differentiate it from the sibling tool 'timezone' or explain any special boundary, so it is clear but not fully distinct.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives, and it mentions no exclusions or preferred context. An agent is left to infer that the tool is for retrieving UTC time, but there is no routing cue relative to timezone or other time-related tools.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does state that the body is discarded, which is helpful, but it omits what the check returns, how invalid JSON is reported, and any error or edge-case 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, front-loads the primary action, and the second sentence adds a meaningful side-effect note. There is no redundant filler.

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

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

Without an output schema or annotations, the description is too thin: it does not explain the return value, which parameter represents the 'body', or how the seven schema parameters relate to JSON validation. An agent could still guess, but important operational context is missing.

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

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

All seven parameters have descriptions in the schema, so schema coverage is effectively 100%. The description adds no additional semantic value, but it also does not need to carry the parameter-documentation burden.

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

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

The description states a clear verb and resource: check whether a body is valid JSON. It does not explicitly differentiate this from sibling tools like domain-shape or fetch-status, but the core purpose is immediately understandable.

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

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

No guidance is given about when to use this tool rather than a sibling such as fetch-status, web-fetch, or domain-shape. The agent is left to infer the appropriate context entirely from the name.

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

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

There are no annotations, so the description carries the full behavioral burden. It reveals only that the tool fetches current temperature from Open-Meteo; it does not disclose that the other eight schema parameters appear to be ignored/discarded, nor any error handling, units, or side-effect behavior.

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

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

The description is a single front-loaded sentence with no filler, and the key information (current temperature, city, Open-Meteo) appears immediately. It is concise, though arguably too sparse for the tool's complexity.

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

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

Given no annotations and no output schema, the description should explain return format, units, required parameters, and behavior with ignored inputs. It does none of this, and the nine-parameter schema with all-optional fields makes the call contract unclear.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds the pointer that city is the meaningful input, but it doesn't explain the role of the remaining parameters or that they are discarded, leaving the large optional schema ambiguous.

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

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

The description 'Current temperature for a city via Open-Meteo' states a specific resource and data source, clearly identifying the tool's function. It does not explicitly differentiate it from sibling hint tools like geo-hint, so it falls short of a 5.

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

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

No guidance is provided about when to use this tool instead of siblings, whether city is required, or how it relates to other hint tools. The presence of nine unrelated optional parameters makes this omission worse; an agent has no way to know which parameter to populate.

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. 'Body discarded' is a useful behavioral disclosure beyond the schema. However, it omits other relevant behavior such as redirect handling, error behavior, rate limits, or whether any content is persisted or processed.

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

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

Two short sentences, no filler, with the most important operational detail ('Body discarded') front-loaded. The description is appropriately concise for what it does say.

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

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

The description is too thin for a tool with 9 optional parameters, no required fields, and no output schema. An agent cannot tell whether city, feed, json, path, zone, query, and ref are alternative modes, ignored fields, or inputs to a broader polymorphic operation. This is a significant gap in call correctness.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds minimal parameter-level meaning: it identifies 'url' as the primary input via 'public URL'. It does not explain the relationship between the many other accepted parameters and the stated URL-fetching 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 tool returns HTTP status and content type for a public URL, and adds the important clarification that the body is discarded. However, it does not differentiate it from the sibling tool 'fetch-status', which appears to serve a very similar purpose.

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

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

No guidance is given about when to use this tool versus alternatives like fetch-status, browser-url-ok, or normalize-url. The phrase 'public URL' implies a scope constraint, but there are no explicit when-to-use or when-not-to-use instructions.

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

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

The description adds the behavioral note that the title is 'discarded after the call,' which is useful privacy-related context. However, because there are no annotations, it does not explicitly state whether the operation is read-only, whether it makes an external network call, or what happens on failure.

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

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

The description is appropriately brief, with the core action front-loaded in the first sentence. The second sentence about discarding the title adds meaningful behavioral context without redundancy.

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

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

Given the absence of an output schema and annotations, the description should clarify the input parameter, return value, and any side effects. It covers the purpose and data handling but leaves the agent unable to determine how to pass the Wikipedia title or interpret the result.

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

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

The description discusses checking a 'Wikipedia title,' but the input schema contains no 'title' property — only ref, url, city, feed, host, json, and path. The description never tells the agent which parameter holds the title to be checked, making correct invocation impossible.

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

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

The description uses a specific verb and resource: 'Check whether a Wikipedia title exists.' This clearly distinguishes it from sibling tools like normalize-url, validate-json, and web-fetch. The purpose is immediately unambiguous.

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

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

No guidance is provided about when to use this tool versus alternatives such as web-fetch or browser-url-ok. There is no mention of prerequisites, exclusions, or conditions that should route an agent here instead of elsewhere.

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