YAML key count, body discarded

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

No annotations are provided, so the description must carry full behavioral disclosure. It mentions 'Task text discarded' which is ambiguous (no 'task' parameter exists) and doesn't cover side effects, auth needs, or data handling. The statement about returning outputs is helpful but incomplete.

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

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

Two sentences with the core purpose front-loaded. It's efficient, but the 'Task text discarded' phrase is confusing and adds noise, slightly reducing clarity.

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

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

Given 9 optional parameters, no output schema, and no annotations, the description is insufficient. It doesn't explain how the parameters are used together, what the return format looks like, or when to invoke this tool, leaving 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?

Schema coverage is 100% with each parameter having a description, so the baseline is 3. The tool description adds no additional meaning about how the parameters relate to the gateway lookup, so it doesn't go beyond the schema.

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

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

The description clearly states a specific purpose: find a public pay-per-call tool gateway (Monid) and lists the outputs (CLI setup, how-it-works, skill file, remote MCP hops). This distinguishes it from siblings by its unique function, though it doesn't 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?

No guidance on when to use this tool versus the many sibling tools. It doesn't mention conditions, exclusions, or prerequisites, leaving the agent to infer appropriate use.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states 'No browser is launched,' but does not explain what the tool actually does with the inputs, what it returns, or any side effects. Given the schema descriptions repeatedly mention 'discarded after...', the tool appears to be a shape checker, yet the description hides this entirely.

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 sentence), but it lacks structure and fails to front-load any actionable detail. Conciseness here is not a virtue because it omits critical information; the single sentence is under-specified rather than efficiently scoped.

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

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

For a tool with 9 parameters, no output schema, and no annotations, the description is grossly incomplete. It does not explain what the tool does with the parameters, what it returns, or when to use it. An agent cannot correctly 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?

Schema coverage is 100%, so each parameter has a description that conveys its role. However, the main description adds no meaning beyond the schema; it doesn't clarify how parameters relate to the stated URL-checking purpose. The baseline of 3 applies because the schema carries the semantic weight, but the description fails to integrate them.

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

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

The description states a clear verb and resource ('Check whether a URL can be opened'), but it conflicts with the input schema, which accepts 9 heterogeneous parameters (git ref, city, JSON, file path, timezone, etc.) that have nothing to do with URL checking. This mismatch makes the purpose misleading and hard to align with the actual behavior.

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. There is no mention of appropriate contexts, exclusions, or how it differs from siblings like playwright-url-ok or fetch-status. An agent receives zero routing information.

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 'Evaluate a+b style arithmetic. Expression discarded.' This is cryptic and does not explain what the tool actually does with the nine parameters, what side effects occur, or what the return value is. The schema descriptions ('discarded after the shape check') hint at validation, but the description contradicts that by implying arithmetic evaluation.

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 conciseness is not the issue—it is under-specification. The single sentence provides no actionable structure or key information; it wastes the reader's time by claiming arithmetic evaluation while the schema shows a different set of inputs.

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 required fields, and no output schema, the description is grossly incomplete. It does not explain the tool's actual function, how to choose parameters, what the return format is, or when to use it. An agent has almost no chance of correctly invoking this tool 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 the baseline is 3, but the description actively misleads by implying an 'expression' input that does not exist in the schema. It adds no meaning to the actual parameters (ref, url, city, etc.) and fails to connect them to the stated purpose, making the tool harder to use correctly rather than easier.

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 ('Evaluate a+b style arithmetic'), but it is misleading because the input schema contains no expression parameter—instead listing nine unrelated optional parameters like ref, url, city, and feed. This mismatch confuses rather than clarifies what the tool actually does, so it falls short of a clear purpose statement.

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 the many siblings (e.g., normalize-url, validate-json, search-query-len). It neither states typical use cases nor excludes alternatives, leaving the agent to guess based on the misleading name and description.

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

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

With no annotations, the description must carry the burden of behavioral disclosure. It does disclose that 'Page content is not stored,' which is useful, but it says nothing about side effects of the other parameters, whether network requests are made, or how the tool treats the non-URL fields. For a tool with this many parameters, the 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 sentence that is easy to parse and front-loads the core function. It is appropriately short, though it omits necessary context about the other parameters. Conciseness itself is good, but the brevity contributes to the incompleteness.

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 parameters, no output schema, many siblings), the description is severely incomplete. It does not explain the purpose of the extra parameters, how the output is formatted beyond three fields, or how it differs from overlapping tools. An agent cannot confidently call this tool correctly with only the provided description.

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% coverage, so each parameter has a description, satisfying the baseline of 3. However, the tool description adds no extra meaning beyond the schema – it only mentions 'URL' while the schema describes the other parameters as discarded or validated. The description does not clarify how these parameters relate to the stated output, so it neither helps nor harms beyond the baseline.

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

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

The description states a clear core action – 'Return host, scheme, and HTTP status for a URL' – but the input schema includes 9 parameters, many of which (city, zone, json, path) have nothing to do with URLs. The description gives no hint of what these parameters do, making the tool's actual scope ambiguous and potentially misleading an agent into thinking it only accepts a URL when it accepts many other inputs.

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

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

There is no guidance about when to use this tool versus the many siblings (e.g., normalize-url, fetch-status, browser-url-ok). No mention of alternatives, no exclusions, no contextual triggers. An agent cannot distinguish this tool's appropriate use case from overlapping 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 provided, the description carries the full burden of behavioral disclosure. It adds one useful privacy note ('No identifiers are retained') but fails to state that the operation is read-only, what the output looks like, or whether any side effects occur. For a tool that accepts file paths and URLs, the absence of safety context 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 two sentences and very short, which is concise. However, it's under-specified: the first sentence is vague and the second is a privacy note. It's appropriately front-loaded in that the purpose comes first, but the purpose is too ambiguous to be useful. It's not bloated, but it's also not informative enough 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?

Given 9 parameters, no annotations, and no output schema, the description is severely incomplete. It doesn't explain what 'classified' means, what the output will be, how the parameters relate to each other, or when to use this catch-all versus a specialized sibling. An agent has almost no basis 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 individual descriptions (e.g., 'discarded after the shape check', 'no disk access'). The description itself adds nothing about parameters, but the baseline is 3 because the schema already documents them thoroughly. The description's generic phrasing doesn't compensate or add value beyond the schema.

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

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

The description states a verb ('Show') and a resource ('request') but leaves 'classified' undefined. It doesn't specify what classification means, what categories exist, or how it differs from the many sibling shape-check tools like domain-shape, jira-key-shape, or validate-json. It's not a tautology, but it's vague enough that an agent cannot infer its unique role.

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

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

No guidance is given on when to use this tool versus the 28 siblings. The description doesn't mention alternatives, conditions, or exclusions. An agent has no way to decide whether to call this or a more specific tool 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.

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

With no annotations, the description carries the full burden. It states 'without WHOIS or ownership data,' which is a useful exclusion, but it says nothing about what happens with the other eight parameters, whether it makes network calls, what it returns, or any side effects. The behavior for most of the schema is completely undisclosed.

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 lacks structure and does not front-load critical information. It is too brief to be genuinely helpful, providing only a minimal statement without elaboration. While there is no wasted words, the brevity comes at the cost of substance.

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

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

The tool has 9 parameters, no annotations, and no output schema, making the description's role critical. The description only addresses a single function (hostname splitting) and ignores the rest of the schema, leaving most inputs unexplained. It is incomplete for a tool of this complexity, offering insufficient context 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%, and each parameter has a clear description (e.g., 'Git ref name; discarded after the shape check'). The tool description adds no additional parameter semantics, so the baseline of 3 applies. It neither enhances nor contradicts the schema's parameter explanations.

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

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

The description clearly states a specific action: 'Split a hostname into labels without WHOIS or ownership data.' This is a precise verb and resource. However, the input schema contains many unrelated parameters (city, json, path, zone, query) that are not mentioned, creating ambiguity about the tool's actual scope. The description only covers a narrow function, which could mislead an agent into thinking the tool is exclusively for hostname splitting when the schema suggests broader shape-checking capabilities.

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 its siblings like github-repo-shape or jira-key-shape. The description does not mention any conditions, prerequisites, or exclusions. An agent has no basis to choose this tool over alternatives beyond 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?

With no annotations, the description must carry the full behavioral burden. It discloses that it performs a HEAD request and returns status only, but it does not explain that it also validates other input types (e.g., git ref shape, JSON validation, timezone check) as implied by the schema. It also fails to mention network dependencies, error handling, or redirect behavior. This is a significant gap given the tool's multi-purpose nature.

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, just one sentence, which is structurally clean and front-loaded. However, it is so brief that it omits the tool's broader functionality, making it more under-specified than concisely complete. It earns a 3 because it is efficient but not adequately 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?

Given the complexity of 9 optional parameters and no output schema or annotations, the description is far from complete. It only mentions URL handling and does not describe the status output format or the behavior for other input types. An agent cannot reliably call this tool for non-URL inputs without guessing. This is a major 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 each parameter already has a description. The tool description adds a small amount of meaning by linking 'url' to a HEAD request, but it does not clarify how the other parameters are used or what 'status' means for each. Since the schema covers the parameters, the baseline of 3 is appropriate, though the description could add more context for non-URL parameters.

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

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

The description states a specific action (HEAD a public URL) and the output (status only), but it only mentions the 'url' parameter while the schema has 8 other parameters (ref, city, feed, host, json, path, zone, query) that the tool also handles. This makes the purpose incomplete and potentially misleading for an agent that expects to check other input types. It is not a tautology but it under-specifies the 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?

The description provides no guidance on when to use this tool versus siblings like browser-url-ok, playwright-url-ok, web-fetch, or normalize-url. There is no mention of alternatives or exclusion criteria. An agent cannot infer the appropriate context for this tool without additional information.

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 mentions 'Path discarded.' It does not state whether the operation is read-only, what it returns (e.g., a boolean, extracted parts, or an error), or how it handles invalid inputs. The presence of unrelated parameters (city, feed, json) suggests a broader shape-checking role that the description fails to acknowledge, which could mislead an agent.

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 non-redundant, but it is too sparse for a tool with nine parameters and no annotations. The main purpose is front-loaded, yet essential details (like what the tool returns or how to use it) are omitted. It is not verbose, but it lacks structure and completeness.

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

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

Given the complexity (nine parameters, no output schema, no annotations), the description is severely incomplete. It does not explain return values, usage conditions, or the role of each parameter. The tool appears to be a generic shape-checker based on the schema, but the description claims only Figma URL parsing, leaving an agent without enough information to invoke it correctly.

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

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

Schema coverage is 100%, so each parameter has a description, but the tool description does not explain how the parameters relate to the stated purpose of parsing a Figma URL. The inclusion of parameters like city, feed, and zone suggests the tool may check multiple input shapes, contradicting the narrow 'Figma file URL' focus. This mismatch undermines clarity and leaves the agent to guess which parameters are relevant.

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

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

The description states a specific verb ('Parse') and resource ('Figma file URL'), which is clear. However, 'parse' is vague—it could mean validate, extract components, or normalize—and it does not distinguish this tool from siblings like normalize-url or browser-url-ok. The added 'Path discarded' hints at behavior but doesn't clarify the tool's overall 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 on when to use this tool versus alternatives. It is implied it handles Figma URLs, but there is no mention of when not to use it or what distinguishes it from similar URL-handling tools. The description does not state any prerequisites or conditions.

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

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

With no annotations provided, the description carries the full burden. It discloses 'No disk access' but does not explain what 'safe' means, what the return value looks like (boolean, error, etc.), or that most input parameters are ignored after a shape check. These are significant behavioral gaps.

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

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

The description is a single sentence, which is concise and front-loaded with the primary action. However, given the tool's complex nine-parameter schema and lack of annotation context, the brevity sacrifices necessary detail and comes across as 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?

The description is incomplete for the tool's context: no output schema, no annotations, and many sibling tools. It does not explain the return type, usage scenarios, or how to handle the non-path parameters, leaving an agent without enough information 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%, so each parameter has a description, but the tool description adds no meaning beyond repeating 'path' and 'no disk access'. It fails to clarify that only the 'path' parameter is actually used and that the other eight are discarded, which is critical for an agent deciding what to populate.

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

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

The description states a specific verb ('Check') and resource ('path'), and adds a behavioral note ('No disk access') that distinguishes it from disk-touching tools. However, it does not clarify that only the 'path' parameter is relevant given the schema exposes nine unrelated parameters, which could mislead an agent about the tool's actual scope.

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

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

There is no guidance on when to use this tool versus the many shape-checking siblings (e.g., browser-url-ok, domain-shape). The description neither mentions exclusions nor conditions that would route an agent here, leaving the choice 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?

With no annotations, the description must disclose behavior, but it only offers a single sentence. It fails to mention that most parameters are discarded after checks, that the result is a 'hint' rather than definitive coordinates, or that it relies on an external weather API. No behavioral context is given.

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 but under-specified and misleading. It is a single sentence that doesn't front-load the essential information; instead, it leads with a claim that doesn't align with the schema. The brevity is not beneficial because it omits necessary details.

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 and with nine optional parameters, the description is severely incomplete. It doesn't explain the return format, which parameters are needed for a meaningful call, or how the tool behaves with different inputs. An agent cannot correctly invoke this tool based solely on the description.

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% coverage with per-parameter descriptions, but the tool description adds no value in linking these parameters to the stated purpose of returning lat/long. For instance, the schema describes 'ref' and 'json' as discarded inputs, yet the description doesn't clarify which parameter (if any) identifies the 'place' for which coordinates are returned, creating a semantic disconnect.

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 it provides latitude and longitude for a place via Open-Meteo, which is a specific claim, but the input schema contains nine unrelated parameters (ref, url, feed, json, path, etc.) with no clear connection to geolocation. This creates ambiguity about the tool's actual purpose and fails to distinguish it from siblings like weather-hint or timezone.

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 any of its 26 siblings. The description doesn't mention any conditions, exclusions, or alternatives, leaving an agent completely without direction for tool selection.

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

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

No annotations are provided, so the description carries the full burden. It only says 'Parse', implying a read operation, but doesn't disclose that most parameters are discarded (though the schema descriptions do), doesn't describe error behavior or output format, and doesn't clarify side effects. For a tool with 9 parameters, 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 concise sentence, which is not verbose. However, given the tool's complexity (9 parameters) and the existence of many sibling tools, the description is under-specified. It does front-load the core purpose but lacks detail needed for correct usage.

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

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

The tool has no output schema and a 9-parameter input schema with no required fields. The description doesn't explain what the tool returns (owner/repo presumably), how the parameters are used, or what happens with invalid input. Given the complexity, this is insufficient for an agent to call the tool correctly.

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

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

Schema coverage is 100%, so each parameter has a description, but the tool description adds no meaning beyond the schema. It doesn't explain how the parameters relate to parsing owner/repo or which are required. The baseline for full schema coverage is 3, and the description neither enhances nor contradicts 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?

States a specific verb ('Parse') and resource ('owner and repo from a GitHub URL'), which distinguishes it from sibling shape tools like domain-shape and figma-url-shape. However, it doesn't clarify the purpose of the many additional schema parameters, leaving ambiguity about what the tool actually does with them.

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

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

No guidance on when to use this tool versus the many sibling shape tools. It doesn't mention prerequisites, conditions, or alternative tools for non-GitHub URLs. The description only states the action without context for selection.

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 exist, so the description carries the full burden of disclosing behavior. It only says 'Titles discarded,' which is opaque; it does not reveal that the tool likely fetches HN data, what network access is needed, whether the count is cached, or what the output format is. The description contradicts its own purpose by implying the parameters are discarded, yet the tool's name suggests a counting operation.

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

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

The description is extremely concise (one sentence) but this is under-specification rather than effective conciseness. It front-loads the main action but omits essential context, making it unsuitable for agent 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?

With 9 parameters, no output schema, and no annotations, the description is grossly incomplete. It fails to explain the tool's actual functionality, how parameters affect the result, what the output represents, or any constraints. An agent has no way 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?

Although the schema provides 100% coverage with descriptions for each parameter, the tool description adds no meaning about how these parameters relate to counting Hacker News stories. The parameters are generic (ref, url, city, etc.) and appear irrelevant; the description does not explain why they are accepted or what role they play, leaving the agent unable to determine correct values.

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 ('Hacker News front-page stories'), but the phrase 'Titles discarded' is cryptic and the nine parameters (ref, url, city, feed, host, json, path, zone, query) are entirely unrelated to Hacker News, making the actual purpose ambiguous. It does not differentiate from siblings beyond the unique name, and the description leaves doubt about what the tool actually counts or why these parameters exist.

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 any of the 28 siblings. There is no mention of context, prerequisites, or alternatives, leaving an agent without any decision support.

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 disclosing behavior. It says nothing about side effects, network access, data retention, or return format. The schema descriptions mention discarding some parameters, but that is not in the description. For a tool with nine parameters, this is a major 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 short sentence, which is concise but far too sparse for a tool with nine parameters. It is not structured or front-loaded with key operational details. Conciseness is not a virtue here because 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 a complex input schema with nine parameters, no annotations, and no output schema. The description only provides a vague statement about timezone names for clock calls, which is wholly insufficient to understand the tool's actual behavior, expected inputs, or outputs. An agent cannot reliably invoke this tool based on the description.

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 parameters have detailed descriptions in the schema itself. The tool description adds no additional parameter context. The schema already documents that some values are discarded after checks, so the baseline of 3 is appropriate; the description does not add or detract 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 states that the tool provides 'Common IANA timezone names for clock calls,' which gives a resource and a domain but not the specific action (list, validate, resolve). It is not a tautology, but it does not clarify whether the tool returns a list, validates a zone, or performs another operation, nor does it distinguish it from siblings like timezone or utc-time.

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

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

There is no guidance on when to use this tool versus alternatives. No mention of conditions, exclusions, or relationships to sibling tools like timezone or utc-time. An agent has no basis for choosing this tool over others.

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

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

With no annotations, the description must carry the full behavioral burden. It claims to fetch robots.txt, but the parameter descriptions indicate a shape-checking behavior ('discarded after the shape check') for most fields, which contradicts the stated purpose. The description omits any mention of side effects, rate limits, or why many parameters are discarded. This is misleading and severely undermines transparency.

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

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

The description is a single sentence, which is concise, but it is vague and omits critical details about parameter usage. It is under-specified rather than efficiently concise, leaving the agent to guess at the tool's actual behavior.

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 output schema, and no annotations, this description is grossly incomplete. It does not explain which parameter specifies the robots.txt URL, what 'group counts' means, or how the many other parameters relate. The agent lacks essential information to call the tool correctly.

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

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

Schema description coverage is 100%, so each parameter has a description, but those descriptions conflict with the tool description. They indicate the parameters are used for shape checks and then discarded, not for fetching robots.txt. The agent cannot determine how to set the URL or why other parameters exist. The schema adds no coherent semantic link to the tool's declared 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 states a specific verb ('Fetch') and resource ('public robots.txt') and the output ('group counts only'). This is clear on the surface. However, it does not differentiate from sibling tools like web-fetch or fetch-status, which could also fetch a robots.txt. The purpose is clear but not uniquely scoped.

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

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

There is no guidance on when to use this tool versus alternatives, nor any mention of prerequisites or exclusions. The description gives no context about which input to supply (e.g., which parameter holds the robots.txt URL) or when it is preferable to other fetch 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?

No annotations are provided, so the description carries the full burden. The description only says 'Key discarded,' which hints at non-retention but does not explain what the tool does with the input, what it returns, whether it makes external calls, or what 'shape check' entails. This is almost no behavioral information 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 very short (two sentences), which is concise, but it is under-specified. It front-loads the purpose but omits essential detail. This is more under-specification than effective conciseness, as a single purpose statement is not enough for a tool with this 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 9 parameters, no required fields, no output schema, and no annotations, the description is grossly incomplete. It does not state which parameter is the key, what constitutes a valid shape, what the tool returns, or any side effects. An agent cannot reliably invoke this tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds no value beyond the schema and actively confuses: it says 'Jira issue key' yet none of the parameters (ref, url, city, feed, host, json, path, zone, query) resemble a Jira key. The schema descriptions themselves are generic and do not connect to Jira, so the parameter semantics are not clarified.

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

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

The description states a specific verb and resource ('Check a Jira issue key shape'), which gives a clear purpose in isolation. However, the input schema contains nine parameters, none of which is a Jira issue key, so the mapping between the stated purpose and the actual inputs is ambiguous. It also does not differentiate from sibling shape-checking tools like 'domain-shape' or 'github-repo-shape'.

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

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

There is no guidance on when to use this tool versus the many sibling shape-checking tools. No conditions, alternatives, or exclusions are mentioned. An agent would have to infer usage entirely from the name, which is insufficient.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the body is discarded, which is useful, but says nothing about redirects, timeouts, authentication, or error behavior. The schema parameter descriptions mention values are 'discarded after the check' for several fields, but the main description does not integrate this into a coherent behavioral model.

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

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

The description is extremely concise: two short sentences with no fluff. The primary action ('HTTP status') is front-loaded, and the key behavioral note ('Body discarded') follows immediately. Every word earns its place, though this brevity contributes to incompleteness elsewhere.

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 required fields, no output schema, and no annotations, the description is far from complete. It does not explain what the tool returns beyond a status code, how to interpret the response, which parameters are actually relevant to the core function, or why the schema includes unrelated fields. An agent would struggle to call this correctly 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?

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-specific meaning beyond the schema. The schema descriptions themselves are often vague or mismatched (e.g., 'url' is for normalizing/citing, but the tool is about HTTP status), yet the description does not attempt to reconcile these or clarify which parameters are actually used for the HTTP status 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 clearly states the action: returns HTTP status for a public library docs URL and discards the body. This is a specific verb+resource, but it does not differentiate from sibling tools like fetch-status or browser-url-ok. The 9-parameter schema, however, introduces confusion by including unrelated fields (city, feed, json, zone, etc.), so the stated purpose does not fully align with 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 versus alternatives. It does not mention exclusions, prerequisites, or typical use cases. An agent cannot decide between this and fetch-status, normalize-url, or browser-url-ok 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 provided, the description must carry the full behavioral burden. It only discloses that values are discarded, but does not mention side effects, authentication requirements, rate limits, error handling, or what happens with invalid inputs. This is insufficient for a tool with many 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 concise at two short sentences with no filler, and the key fact ('Count keys in a JSON object') is front-loaded. However, it is under-specified, so conciseness is achieved at the cost of clarity.

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 required parameters, no output schema, and no annotations, the description is far too brief. It does not explain how the parameters relate to the stated purpose or what the output format is, leaving an agent unable to call the tool correctly in many cases.

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% coverage, with each parameter described clearly (e.g., 'JSON text to validate; discarded after the check'). The tool description adds no additional meaning beyond the schema, so it meets the baseline for high schema coverage but does not enhance 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 states 'Count keys in a JSON object' which names a specific action and resource, but it is ambiguous given the input schema includes many unrelated parameters (url, city, feed, host, etc.) that are not about JSON objects. It does not differentiate from sibling tools like yaml-key-count or validate-json, leaving the agent uncertain about when this tool is appropriate.

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 any conditions, exclusions, or preferred contexts, which is a significant gap given the large set of sibling tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states that query and fragment are dropped, which is a key behavioral trait. However, it does not mention error handling for invalid URLs, what happens if the input is not a valid URL, or whether the operation is side-effect free. Given the simplicity, the description covers the main behavior but leaves some 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 extremely concise, consisting of two short sentences. The main purpose is front-loaded, and there is no unnecessary verbiage. Every word contributes to understanding what the tool does.

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 insufficient for the tool's complexity. Although the schema has 9 parameters, the description only addresses URL normalization and says nothing about the other parameters (ref, city, feed, host, json, path, zone, query). It is unclear whether these are ignored or used in some way. An agent cannot fully understand how to call this tool correctly, especially since the schema's parameters seem unrelated to the described behavior. The description should clarify that only the 'url' parameter is used, or explain how the others factor in.

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 for its 9 parameters, so the baseline is 3. The tool description does not add additional meaning to any parameter; it only mentions the URL concept, while the schema includes unrelated parameters like city, json, and zone. The description does not clarify how these parameters are used, but since the schema already describes them, the description does not need to repeat that. It provides marginal value beyond the schema.

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

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

The description clearly states the tool's function: 'Return origin, host, and path for a URL. Query and fragment are dropped.' This uses a specific verb (Return) and resource (URL), and the behavior distinguishes it from siblings like browser-url-ok (which checks availability) and domain-shape (which validates shape). The purpose is unambiguous and non-tautological.

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 for normalizing URLs, but it does not explicitly state when to use this tool versus alternatives such as domain-shape or figma-url-shape. It also does not mention any exclusions or prerequisites (e.g., whether the URL must be valid). The guidance is adequate but relies on the agent inferring the tool's role from its name and description.

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

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

With no annotations, the description carries full responsibility for disclosing behavior. It only states that no browser is launched, but does not mention whether network requests are made, what the return value looks like, side effects, or how parameters are used. The schema descriptions for many parameters say 'discarded after', which is confusing and not addressed in 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 a single sentence, which is concise but severely under-specified for a tool with nine parameters. It lacks any structural breakdown, examples, or elaboration on the check process. Brevity is not an asset when it leaves critical information missing.

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 (nine parameters, no output schema, no annotations), the description is grossly inadequate. It does not explain what the tool returns, error conditions, how to use the parameters, or any behavioral nuances. An agent cannot reliably invoke this tool correctly 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?

Schema coverage is 100%, so the baseline is 3, but the description adds no meaning beyond the schema. It fails to explain why the tool accepts parameters like city, json, zone, or query when its stated purpose is URL checking. The schema descriptions themselves are vague (e.g., 'discarded after') and the tool description does not clarify their role, making the parameters semantically unclear.

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

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

The description states a clear verb and resource ('Check whether a URL can be opened') and adds a clarifying note about no browser launch. However, it does not specify what 'opened' means (e.g., HTTP status, reachability, format) and does not differentiate from siblings like 'browser-url-ok' or 'fetch-status'. The presence of nine parameters, many unrelated to URLs, further muddies the 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 on when to use this tool versus alternatives. The only hint is 'No browser is launched', implying a lightweight check, but there is no explicit comparison with siblings or conditions that would select this tool over others.

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 only states 'Query discarded,' which discloses that the query is not retained, but it does not mention the return format (whether a number or boolean), whether other parameters are also discarded, or if there are any side effects. This is insufficient for an agent to predict 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 two short sentences with no fluff. It is concise and front-loaded with the core action. However, it is under-specified, but that is a completeness issue, not a structure 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?

Given the complexity (9 parameters, no output schema), the description is incomplete. It does not specify what the tool returns (e.g., a count, a boolean), nor does it clarify which parameter is the 'search query' or how the other parameters factor in. An agent would struggle to call this tool correctly without opening the schema and inferring intent.

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 is already documented in the schema. The tool description adds no extra meaning about parameters beyond repeating the query concept. Since the schema does the heavy lifting, 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 verb and resource: 'Count characters in a search query.' However, the input schema includes 9 unrelated optional parameters (ref, url, city, feed, host, json, path, zone) alongside 'query', and the description gives no hint about how these relate to the stated purpose. An agent cannot tell if the tool accepts any of these strings or only 'query'.

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 like yaml-key-count or memory-key-count. The description and name imply it is for search query length, but no explicit context or exclusions 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 provided, the description must carry the full burden of behavioral disclosure. It doesn't state whether the tool is read-only, what side effects occur, or what happens to the discarded parameters. The description is silent on all behavioral traits.

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 under-specified rather than concise. It lacks structure, has no front-loaded critical information, and does not earn its place because it provides almost no useful 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?

For a tool with 9 diverse optional parameters and no output schema, this description is grossly inadequate. It gives no hint of how inputs are used, what the tool returns, or any constraints, making it impossible for an agent to call correctly.

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

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

Although schema coverage is 100%, the description adds no meaning beyond the individual parameter schemas. It fails to explain how parameters like 'city' or 'json' relate to HTTP status codes, leaving the agent without a coherent understanding of the tool's inputs.

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

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

The description states the tool is a 'short catalog of common HTTP status codes,' which names a resource but no verb or action. It doesn't say what the tool does with the nine unrelated input parameters (ref, url, city, feed, etc.), nor does it distinguish it from siblings like fetch-status or browser-url-ok. The purpose is vague and not 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 provided on when to use this tool versus alternatives. The one-sentence description offers no context, conditions, or exclusions, leaving the agent to guess.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only states 'Prompt discarded', which is unclear and does not explain side effects, read-only nature, or what happens to the parameters. The tool's actual behavior (e.g., whether it is a pure function returning a static template) is not disclosed.

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

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

The description is only two sentences and is technically concise, but it is under-specified for a tool with 9 parameters. It lacks necessary detail and reads as incomplete rather than efficiently written.

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 parameters, no output schema), the description is severely incomplete. It does not explain what the three-step template is, how the parameters influence the output, or what the return value looks like. An agent cannot confidently determine how to call this tool correctly.

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

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

Schema coverage is 100%, with all 9 parameters having descriptions in the input schema. The description adds no parameter-specific information, but since the schema already documents each parameter, the 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 specific action ('Return a three-step thinking template') and resource, but it is vague about what the template contains or how it differs from sibling tools like 'agent-tool-index' or 'status-catalog'. The phrase 'Prompt discarded' adds ambiguity 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 alternatives. It does not mention any conditions, prerequisites, or sibling tools, leaving the agent to infer usage context from the name and description alone.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states only the primary function and fails to disclose that all parameters except 'zone' are discarded, which is a notable behavioral trait. It also omits any mention of network dependency, return format, 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 a single, concise sentence that front-loads the core purpose. There is no wasted language, and it is immediately clear what the tool does at a high level.

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. The description is far too sparse to guide correct invocation. It does not explain which parameter to use, what the return value looks like, or why so many unrelated parameters exist. An agent would be left guessing about the appropriate usage.

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 description coverage is 100%, so the schema already documents each parameter. The tool description adds no additional meaning beyond what the schema provides. It does not clarify that 'zone' is the only relevant parameter, which would be valuable, but the baseline of 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 states a specific verb and resource: 'Current time in a named IANA timezone.' It clearly indicates the tool's core function and is distinguishable from siblings like utc-time and iana-zones. However, it does not mention that the schema includes many unrelated parameters, which may confuse an agent about the tool's actual scope.

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

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

The description provides no guidance on when to use this tool versus alternatives such as utc-time or iana-zones. It does not specify that the zone parameter is the relevant one and that other parameters are discarded. There is no explicit context or exclusionary 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 provided, so the description carries the full burden of behavioral disclosure. It only states what it returns ('Current UTC timestamp') but does not disclose whether the operation is read-only, any side effects, output format, or error conditions. For a tool with no annotations, 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, concise and to the point. It earns its place by stating the core purpose. However, it is almost terse to the point of being under-specified, which slightly reduces the 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?

The tool has 9 optional parameters that are not mentioned in the description, and their connection to a UTC timestamp is unclear. No output schema is provided, so the description should clarify the return format and any additional behavior. The description is too minimal to be complete for an agent that needs to call this tool correctly.

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

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

The input schema includes 9 parameters, all with descriptions, and schema_description_coverage is 100%. Thus, the schema already provides clear semantics for each parameter. The description adds no parameter information, but since the schema covers them, the baseline of 3 applies. The description does not compensate for the fact that the parameters seem unrelated to a UTC timestamp.

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 purpose: return the current UTC time. It uses a specific verb+resource, making it easy to understand what the tool does. However, it does not differentiate from sibling tools like 'timezone' or 'iana-zones', which may also deal with 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?

No guidance is provided on when to use this tool versus alternatives. The description gives no context for when this tool is appropriate, nor does it mention any exclusions or prerequisites. An agent would have to infer its use solely from the name and the description.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the body is discarded (a useful non-persistence trait, reinforced by the schema param descriptions), but says nothing about behavior on invalid JSON, error responses, or return format. For an unannotated tool this is a thin disclosure.

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

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

Two sentences, zero filler, and the core purpose is front-loaded. However, at this length it borders on under-specification rather than disciplined conciseness, especially given the odd collection of nine unrelated 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?

The tool has 9 parameters, none required, no output schema, and no annotations, and the description does not explain why params like city, zone, and query are present or which one constitutes the 'body'. A checker with this much surface area needs more guidance to be safely invoked.

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

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

Schema description coverage is 100%, so baseline 3 applies. The description itself adds nothing about parameters beyond what the schema already provides, and the term 'body' introduces mild ambiguity versus the 'json' parameter. The schema's own per-param notes (e.g., 'discarded after the check') carry the semantic weight.

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 whether a body is valid JSON') and discloses that the body is discarded. It conveys the core function clearly, though 'body' doesn't map unambiguously to the 'json' parameter in the schema, and it doesn't differentiate from the many sibling shape-check tools (file-path-ok, github-repo-shape, etc.).

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

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

No when-to-use guidance, no exclusions, and no mention of alternatives. With 28 sibling tools that follow the same shape-check pattern, there is nothing helping the agent decide between validate-json and tools like file-path-ok 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 full responsibility for behavioral disclosure. It states the operation is a read (get temperature) but does not mention that other parameters are discarded, whether there are rate limits, or what the response format is. The presence of 9 unrelated parameters in the schema without explanation could mislead an agent into thinking they are all relevant.

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

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

The description is a single, front-loaded sentence with no filler. It is appropriately concise for stating the core purpose. However, given the complexity of a 9-parameter schema, a bit more context about parameter relevance could be added without losing 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?

The description is incomplete for a tool with 9 parameters and no annotations or output schema. It doesn't explain that only 'city' is used, nor does it describe the expected output (units, format). An agent would have to inspect the schema and sibling names to guess that other parameters are irrelevant. Key operational details like network access or error handling are also absent.

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 all parameters have descriptions. The description adds no parameter-level meaning beyond the schema; it merely reiterates the 'city' parameter's role. Since the schema already documents each parameter, the description doesn't compensate for or clarify the parameter usage, leaving the agent to infer that only 'city' matters.

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

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

The description clearly states the tool's purpose: retrieving the current temperature for a city via Open-Meteo. It names a specific verb, resource, and data source, which distinguishes it from sibling tools like geo-hint. However, it doesn't clarify that only the 'city' parameter is relevant among the 9 schema parameters, leaving some ambiguity about its 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. There is no mention of context, prerequisites, or exclusions. The description only states what the tool does, not when an agent should select it over other hint 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 only states 'Body discarded' and mentions HTTP status/content type, but does not describe the return format, error behavior, permissions, or rate limits. This is minimal and insufficient for a tool with zero annotation support.

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, front-loads the core purpose, and contains zero unnecessary words. It is appropriately sized for the stated function, even if the function is 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?

The tool has 9 parameters, no output schema, and no annotations. The description does not explain why there are so many unrelated parameters (city, feed, zone, query, etc.), what the return value looks like, or any edge cases. This is a significant gap for an agent to call the tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The main description adds no parameter context, and while the schema describes each parameter, those descriptions are cryptic (e.g., 'discarded after the shape check') and do not explain their relevance to the stated purpose. The description adds no value beyond the schema, but the schema itself is present.

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 it returns HTTP status and content type for a public URL, which is a specific verb and resource. However, it does not explicitly distinguish from sibling tools like fetch-status, which likely serves a similar purpose, so it loses a point for lack of differentiation.

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 mention any context, prerequisites, or exclusions. Given there are many sibling tools with overlapping names (fetch-status, browser-url-ok), an agent has no help deciding which to invoke.

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 carry full behavioral disclosure. It only states 'Title discarded after the call,' which is nonsensical without identifying the title parameter. It does not mention side effects, permissions, return values, or error behavior. This is critically insufficient.

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 under-specified. It omits essential operational details and does not front-load any actionable information. This is not conciseness but under-specification.

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 fails to explain how to use any parameter, what the tool returns, or any error conditions. The tool appears to be a shape-checker based on sibling names, yet the description claims Wikipedia title verification, adding to the incompleteness.

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?

Despite 100% schema coverage, the description adds zero semantic value to any parameter. It does not map any parameter to the 'title' concept, and the schema descriptions themselves (e.g., 'Git ref name', 'City name') appear unrelated to Wikipedia titles. The description fails to compensate for the schema's lack of alignment with the 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 states a verb+resource: 'check whether a Wikipedia title exists.' However, it does not indicate which of the 9 parameters corresponds to the title, making the purpose disconnected from the actual inputs. The phrase 'Title discarded after the call' is ambiguous and 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 siblings like 'browser-url-ok' or 'file-path-ok.' No mention of prerequisites, alternatives, or contextual cues. The agent is left to infer entirely.

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 disclosing behavior. It only states 'body discarded,' which is ambiguous and does not clarify what the tool returns, whether it makes network calls, has side effects, or what 'body' refers to. The behavioral profile is essentially undisclosed.

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 terse, only four words, but it is under-specified rather than appropriately concise. It lacks essential information needed to understand the tool's function, making it more of a placeholder than a useful description.

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 critically insufficient. It does not explain what the tool does with the inputs, what output is produced, or how the parameters are used. An agent would be unable to call 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?

The schema provides 100% coverage with descriptive text for each of the 9 parameters, so the schema itself documents the parameters. The tool description adds no additional meaning beyond the schema, but the baseline for high coverage is 3. Since the description's 'body discarded' phrase does not clarify parameter usage, it adds no value over the schema.

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

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

The description states 'YAML key count' which suggests counting keys in a YAML document, but it does not specify how the provided parameters relate to that task. The parameters include URLs, cities, timezones, etc., none of which clearly indicate YAML input. This is vague and does not distinguish it from similar sibling tools like memory-key-count or hn-front-count.

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

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

There is no guidance on when to use this tool versus alternatives. The description provides no context about the intended use case, conditions for selection, or situations where a sibling tool would be more appropriate.

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