ISO country EE

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

With no annotations supplied, the description carries the full disclosure burden. It does reveal that task text is discarded and names the return payload, but it does not disclose whether the tool makes network calls, incurs pay-per-call costs, requires auth, is read-only, or what happens on invalid inputs.

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 three useful clauses: what it finds, what it returns, and what it discards. No words are wasted.

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

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

Despite the 100% schema coverage, the tool has 9 parameters, no output schema, and no annotations, and the description never explains how the parameters relate to finding the gateway or which one to pass. The meaning of 'Monid' and 'remote MCP hops' is also left unexplained, so an agent cannot confidently invoke this tool.

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

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

Schema description coverage is 100%, and the parameter descriptions are unusually explicit (e.g., 'discarded after the shape check', 'no disk access'). The tool description itself adds no parameter-level semantics, so the baseline of 3 applies.

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

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

The description states a specific action ('Find a public pay-per-call tool gateway') and names the returned artifacts (CLI setup, how-it-works, skill file, remote MCP hops), so an agent can tell what the tool is about. However, 'Monid' is undefined and the description does not explicitly distinguish this from any sibling.

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

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

There is no guidance on when to use this tool instead of the 27 listed siblings, and no conditions or exclusions are provided. 'Task text discarded' hints at what not to rely on, but that is not enough to route an agent.

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 one useful behavior ('No browser is launched') but omits whether the check performs a network request, what 'can be opened' means, whether it is read-only, or whether any permissions or side effects are involved. This is only partial 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?

The description is two short sentences with the primary action front-loaded and the clarifying negative immediately after. Every word earns its place; there is no filler, repetition, or unnecessary detail.

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

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

With 9 parameters, no annotations, and no output schema, this definition is too sparse. It does not state the return value, which parameter an agent should supply, or how 'can be opened' is determined. The rich schema descriptions help, but an agent would still be guessing about invocation and behavioral expectations.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning beyond the schema, but the schema itself already documents each parameter, including the fact that many values are discarded after the check. No adjustment is needed.

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 ('Check whether a URL can be opened') and adds a distinguishing behavioral note ('No browser is launched'), which separates it from browser-launching siblings like playwright-url-ok. However, it does not explicitly name sibling tools or reconcile the URL-focused purpose with the many non-URL parameters in the schema.

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

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

The phrase 'No browser is launched' implies this is a lightweight non-browser check, giving some usage context. But it does not explicitly say when to use this tool over alternatives like normalize-url, fetch-status, or playwright-url-ok, nor does it state when not to use it.

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

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

With no annotations, the description carries the full burden of disclosing side effects. It does disclose that an expression is discarded, which hints at non-persistence, but it omits return behavior, error conditions, and whether any computation result is produced at all.

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 definition is extremely short with no filler or redundant schema repetition. However, the second sentence is ambiguous, so it is efficient but not perfectly clear.

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

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

For a tool with nine parameters, no annotations, and no output schema, this description is too thin to support correct invocation. It does not state return values, which parameter if any is the expression, or what 'discarded' means for the agent's expected result.

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

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

Schema description coverage is 100%, so the baseline is 3; the schema already documents all nine string parameters in detail. The description adds no parameter meaning and actually creates a mismatch by referencing an expression parameter that is absent from 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 gives a verb ('Evaluate') and a resource ('a+b style arithmetic'), but it is nearly a restatement of the tool name and does not specify which input carries the expression. The sentence 'Expression discarded' actively undermines the stated purpose, and no schema property maps to an arithmetic expression.

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

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

There is no guidance about when to choose this tool over any sibling or when not to use it. The only contextual hint is 'Expression discarded,' which gives no information about prerequisites, intended call patterns, or alternatives.

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

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

With no annotations, the description must carry the behavioral disclosure burden, but it only adds the word 'Public.' It does not state whether the call is read-only, what side effects occur, what the response contains, or that most parameters are discarded.

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

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

The description is extremely short, but this is under-specification rather than effective conciseness. Six words cannot meaningfully describe a tool with 9 parameters and no annotations.

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 does not explain the tool's core behavior, return value, or how the many unrelated parameters relate to the 'ISO 3166-1 record.' The schema documents parameters, but the overall contract is incomplete for reliable agent use.

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%, with each parameter individually described, including notes that values are discarded. The tool description itself adds no parameter meaning, but the schema already handles this dimension adequately.

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

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

The description identifies a resource ('Public ISO 3166-1 record for EE') but lacks any action verb, so it does not say whether the tool returns, validates, or references the record. The 9 heterogeneous input parameters further obscure what calling this tool accomplishes.

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

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

No guidance is given about when to use this tool instead of alternatives. There is no mention of scenarios, exclusions, or sibling tools that might overlap, leaving the agent to guess when cc-ee is the appropriate choice.

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

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

With no annotations, the description carries the behavioral burden. It discloses one useful trait — page content is not stored — but it does not describe network access, redirect handling, error behavior, or why eight of nine schema parameters are accepted as optional/discarded inputs.

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 tight sentences with no filler; the primary output is front-loaded and the privacy note is placed second. Every word earns its place.

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

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

This is a sparse definition for a tool with nine optional parameters, no required params, no output schema, and many overlapping siblings. It lacks selection guidance, parameter-priority guidance, and any sense of the return shape or failure modes, so an agent is under-equipped to invoke it correctly beyond the single 'url' case.

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

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

Schema description coverage is 100%, so the baseline is 3; the parameter descriptions already document each field. The tool description adds the output concept (host, scheme, HTTP status) but does not clarify which of the nine optional parameters is primary, though 'url' is the obvious candidate from the schema.

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

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

The description names a concrete output — host, scheme, and HTTP status — for a URL, so the core operation is clear and goes well beyond the tool name. 'Page content is not stored' adds a distinguishing trait, but it does not explicitly contrast with sibling tools such as fetch-status or normalize-url.

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

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

There is no when-to-use or when-not-to-use guidance. With overlapping siblings (fetch-status, normalize-url, web-fetch), an agent cannot tell why citation should be chosen over them, and no exclusions or alternatives are mentioned.

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

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

No annotations exist, so the description carries the transparency burden. It adds one meaningful behavioral guarantee—'No identifiers are retained'—but says nothing about execution side effects, whether the input is sent elsewhere, or what the classification output contains.

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

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

Two short sentences deliver the core purpose and the privacy guarantee with no filler. The main action is front-loaded and the secondary note is separate but relevant.

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

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

With no output schema and nine optional parameters, the description is too thin: it does not explain what the classification returns, how to choose among the parameters, or how to interpret the result. An agent cannot confidently map a request to the correct call from this definition alone.

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

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

Schema description coverage is 100%, so the input schema already documents all nine parameters. The tool description adds no additional parameter meaning 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 and resource ('Show how this request is classified') but leaves the classification scheme unspecified; it never says what categories or kinds of compatibility are being reported. This is clearer than a tautology but too vague to distinguish from the many sibling tools without inspecting the schema.

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 call this tool instead of a sibling such as normalize-url, validate-json, or geo-hint. The description implies a classification/checking role but never states the triggering condition or what to do with the result.

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

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

There are no annotations, so the description carries the behavioral disclosure burden. It adds a meaningful limitation ('without WHOIS or ownership data') and implies a pure lexical operation, but it does not describe return value shape, edge-case handling, or whether the operation is read-only.

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

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

The description is a single, front-loaded sentence with no filler. Every word earns its place: the operation, the target resource, and the key exclusion are all included efficiently.

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 optional parameters, no required fields, no output schema, and no annotations, this terse description leaves too much unspecified. An agent cannot be sure whether to pass only 'host', whether other fields are ignored, or what the split result looks like (array, delimited string, case handling, etc.).

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. Each parameter already has explanatory text, including 'discarded' notes for several fields. The description adds some value by implying the 'host' field is the relevant one, but it does not explicitly say which of the 9 optional parameters should be populated.

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

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

The description states a specific verb and resource: 'Split a hostname into labels.' The qualifier 'without WHOIS or ownership data' distinguishes this tool from richer domain-lookup tools and clarifies its scope relative to shape-check siblings like github-repo-shape and jira-key-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?

The clear context is that this tool is for hostname label splitting, not for WHOIS or ownership lookups. However, it does not explicitly name alternative tools or state when-not-to-use conditions beyond the 'without WHOIS or ownership data' caveat.

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 disclosure burden. It does reveal that this is a HEAD request with a status-only result, but it omits redirect/timeout/auth behavior and does not explain that most of the nine parameters appear to be discarded.

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

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

The description is a single front-loaded sentence with no filler. 'HEAD a public URL and return status only' states the operation and output immediately.

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

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

For nine optional parameters, zero required, no output schema, and no annotations, one sentence is insufficient. Missing details include the exact return format, which parameter is authoritative, and the purpose of the remaining parameters. Only the simplest URL case is covered.

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 mapping between the operation and the nine parameters, leaving unclear whether the caller should pass 'url', 'host', or 'feed' to HEAD a URL.

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

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

The description states a specific method (HEAD), a target (public URL), and a narrow output ('status only'). This clearly distinguishes it from siblings like web-fetch or browser-url-ok, and it is not a restatement of the tool name.

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

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

'Public URL and return status only' implies the intended use case: lightweight reachability/status checks without retrieving content. However, it gives no explicit when-not-to-use guidance and does not name sibling alternatives, so the agent must infer the boundary.

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

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

Annotations are absent, so the description alone must carry behavioral disclosure. It reveals that the path is discarded, but it says nothing about return values, error behavior, or whether any of the other eight schema parameters are meaningful to this tool. That is a partial disclosure, not full transparency.

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

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

The description is extremely concise and front-loaded: two sentences, no filler, and both sentences contribute meaning. It is not verbose, though 'Path discarded' is cryptic enough that the brevity costs 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 nine optional parameters, no annotations, and no output schema, the description is far too sparse to be complete. It does not state what the parse result contains, which parameter to supply, or how this tool differs from related shape/URL tools, so an agent cannot reliably invoke or evaluate the response.

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 has 100% description coverage, all nine parameters are optional and the description never maps 'Figma file URL' to the `url` parameter or explains the purpose of the unrelated parameters. The schema's `url` description ('normalize or cite') also diverges from the stated parse behavior, leaving an agent to guess how to invoke the tool.

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

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

The description states a concrete action ('Parse') and a specific resource ('a Figma file URL'), which matches the tool name and separates it from generic URL tools such as normalize-url or browser-url-ok. The additional 'Path discarded' behavior further clarifies 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 explicit when-to-use/when-not-to-use guidance or mention of sibling alternatives, but 'Parse a Figma file URL' implies the tool should be selected when a Figma URL needs parsing. Without exclusions or alternative routing, the usage guidance is only minimally adequate.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It does disclose one key trait: 'No disk access,' signaling a pure syntactic/shape check with no filesystem side effects. But it does not define what 'safe' means, whether the path must exist, or what result is returned, and the schema implies behavior across many input types.

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

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

The description is a single sentence with no filler, and the 'No disk access' qualifier earns its place by disclosing a critical behavioral boundary. It is appropriately front-loaded and easy to scan.

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

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

This is a 9-parameter tool with no annotations and no output schema, yet the description is only one line. It fails to state return values, clarify what 'safe' means, explain how to choose among the many optional inputs, or account for url/city/zone/query being accepted by a tool named file-path-ok.

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

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

Schema description coverage is 100%, so the baseline is 3; the schema already documents each parameter, including 'discarded after the shape check' for several. The tool description itself adds no parameter-level semantics and does not explain how the path parameter relates to the other eight 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 verb ('check') and resource ('path') and adds a useful qualifier ('looks safe'), so an agent can tell this is a path safety validator. However, it does not distinguish among sibling validators, and the input schema exposes nine unrelated optional properties (url, city, feed, host, json, zone, query), so the description captures only a fraction of the apparent 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 about when to use this tool versus siblings such as domain-shape, browser-url-ok, or validate-json. The only implied usage is 'if you need to check a path without touching disk,' but no when-not conditions or alternative tools are mentioned.

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

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

No annotations are present, so the description carries the full burden. It mentions Open-Meteo as the backend but does not disclose that most inputs are discarded, that an external lookup occurs, or what the response contains.

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

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

The description is short and front-loaded with the core output, but it is a noun phrase rather than an actionable instruction. It is concise without being informative enough to stand alone.

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

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

For a tool with nine optional parameters, no output schema, and no annotations, this one-line description is inadequate. An agent cannot determine which input to provide, what the tool ignores, or what format the coordinates are returned 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?

Schema description coverage is 100%, so the schema documents each parameter. However, the tool description does not explain how 'place' maps to any of the nine parameters; the closest candidate, 'city', is described as being for a 'public weather hint', which creates ambiguity.

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

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

The description signals that the tool provides latitude and longitude for a place using Open-Meteo, so the general purpose is inferable. However, it lacks an explicit verb, does not name the relevant input, and does not distinguish itself 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 or which parameter to populate. With nine optional parameters and no required fields, the description does not indicate that 'city' is the relevant input or that the other parameters are ignored.

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

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

With no annotations, the description carries the behavioral burden. 'Parse' does signal a read-only, syntactic operation rather than a fetch or mutation, which is useful. However, it does not disclose edge-case handling (invalid/non-GitHub URLs), the result format, or that unrelated parameters are ignored, so the behavioral picture is 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?

The description is one front-loaded sentence with no filler: the verb, resource, and result all appear immediately. Every word earns its place.

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

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

There is no output schema and no annotations, so the description must carry the full contract; it only says 'parse' and never states the return shape (e.g., owner and repo as separate fields vs. a combined string) or how invalid GitHub URLs are handled. With 9 optional parameters and many sibling tools, this leaves too much ambiguity for confident invocation.

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

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

Schema description coverage is 100%, so the parameter names and discard semantics are already documented; the baseline is therefore a 3. The description adds only the GitHub-specificity of the url parameter and that owner/repo are the parsed components, but it does not clarify which of the 9 optional parameters is relevant for this call.

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

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

The description states a specific verb ('parse'), a specific resource ('GitHub URL'), and the extracted result ('owner and repo'). This makes the operation clear, though it does not explicitly differentiate itself from sibling URL/shape tools beyond the GitHub-specific wording.

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 GitHub-specific phrasing implies the tool should be used when a caller has a GitHub URL and needs owner/repo extracted, but it gives no explicit when-not-to-use guidance and does not mention alternatives such as normalize-url or browser-url-ok. Usage is left to inference from the tool name and one-line 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 disclose side effects, return shape, or failure behavior; none are provided. 'Titles discarded' hints at output scope but does not state that a live network request is made, what happens on HN unavailability, or what the count value looks like.

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

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

The description is short and front-loaded: the core action appears first. The second sentence is terse to the point of being cryptic, but it does add one relevant behavior clue and there is no redundancy.

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

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

Despite the high schema coverage, the tool has 9 optional parameters and no output schema, and the description does not explain what arguments to use, whether an empty call is intended, or what the returned count format is. This is a material completeness gap for a tool with no annotations.

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

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

All nine parameters are optional and each has a schema description, so the schema already carries parameter-level meaning and the baseline is 3. The description does not clarify which parameters, if any, affect the HN count, but it does not need to compensate because schema coverage is 100%.

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

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

The first sentence names an exact operation ('Count') and target ('current Hacker News front-page stories'), so an agent can distinguish it from the sibling fetch/shape tools even without an explicit comparison. 'Titles discarded' narrows the expected result to a count, removing ambiguity about what is returned.

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 prefer this tool over web-fetch or other sibling tools, and no when-not-to-use conditions or exclusions. The tool's use case must be inferred entirely from the one-line purpose.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only labels a dataset and gives a vague purpose; it does not describe what the tool returns, whether it filters or sorts, or why parameters such as "ref" and "json" are described as discarded.

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

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

The description is very short but under-specified rather than usefully concise. It does not structure any operational guidance, and a single vague phrase is insufficient for a tool with seven parameters and no output schema.

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

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

With no output schema and no annotations, the description must explain what the agent will receive and how the parameters connect to the tool's purpose. It does neither, leaving the tool's behavior, return format, and invocation requirements effectively undefined.

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

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

Schema description coverage is 100%, so the schema already documents each parameter, earning baseline credit. However, the description adds no parameter-level meaning and never explains how values like "url", "city", or "host" relate to IANA timezone names.

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

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

The description is a noun phrase rather than a clear verb+resource statement: "Common IANA timezone names for clock calls" essentially restates the tool name with only a vague usage hint. It does not say whether the tool lists, returns, checks, or resolves these names, and it does not distinguish itself 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?

The phrase "for clock calls" weakly implies a use case, but there is no explicit guidance about when to choose this tool over alternatives such as timezone or utc-time. No conditions, exclusions, or alternative routing are provided, leaving the selection largely to the agent's guessing.

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 tool performs a network fetch and returns only group counts, which is useful. It does not mention failure handling, parse errors, or whether it follows redirects, leaving some behavioral uncertainty.

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

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

A single, front-loaded sentence with no filler. Every word contributes to the core purpose, and the 'only' qualifier is valuable output-scoping information.

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

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

For a tool with nine optional parameters and no output schema, this description is too thin. It does not explain which parameter supplies the robots.txt target, what 'group counts' means structurally, or how the tool behaves when robots.txt is missing or unreachable.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description adds no parameter-specific detail. The description does not clarify which of the nine optional parameters (e.g., url vs host) is used to locate the robots.txt, so it adds no value beyond the already complete schema descriptions.

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

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

The description names a concrete action ('Fetch') and resource ('public robots.txt'), and specifies the narrowing behavior 'return group counts only'. It clearly differentiates the tool from generic fetch tools, though it does not explicitly reference any sibling by name.

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

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

The use case is implied: call this when you need group counts from a public robots.txt. However, there is no explicit guidance about when not to use it or which sibling tool to prefer instead, such as web-fetch or fetch-status.

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

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

The only disclosed behavior is 'Key discarded,' which signals non-retention but is the sole behavioral trait. With no annotations provided, the description carries the full burden and should also explain what the check does, whether it returns a boolean or normalized result, and whether it accesses any external resource; none of that is present.

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

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

The description is very short, front-loads the main action, and contains no filler. Each sentence earns its place: the first identifies the intended operation, and the second adds a non-retention note. The brevity is clear, though it contributes to under-specification rather than being intentionally efficient.

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

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

With seven heterogeneous input fields, no output schema, and no explanation of how those fields relate to a Jira issue key, the description is not complete enough for reliable invocation. It omits return values, parameter selection, error conditions, and any indication of which parameter actually carries the key.

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 all seven parameters have schema descriptions, they are generic disposal notes like 'discarded after the shape check' and none of them mentions a Jira issue key or connects the description's 'key' to a specific field. The description adds no mapping between the stated purpose and parameters such as ref, url, host, or json, so an agent cannot confidently choose the right input.

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

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

The description states a specific verb ('Check') and a specific resource ('a Jira issue key shape'), which distinguishes it from sibling shape tools like github-repo-shape or figma-url-shape. It does not define what 'shape' means or whether this is a regex-style validation, but the core purpose is recognizable.

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

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

There is no guidance on when to use this tool instead of the many sibling shape/validation tools, nor any mention of prerequisites or context. The description merely states the function, leaving the agent to infer when a Jira key shape check should be invoked.

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

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

With no annotations, the description carries the burden, and it does disclose one useful behavior: the HTTP response body is discarded, so the agent knows only the status is returned. It does not mention other behaviors such as redirects, timeouts, or whether any parameters beyond url are used.

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 two sentences are tight and front-loaded, with no filler. But the description is minimal to the point of under-specification for a tool with nine optional inputs, so it is concise without being appropriately sized.

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

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

Given nine optional parameters, no output schema, and no annotations, the description omits too much: it does not explain the role of the other parameters, what the returned HTTP status looks like, or how this relates to the many sibling fetch/status/URL tools. The 'Body discarded' detail is helpful but far from sufficient.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description itself adds no parameter-level meaning. However, the description highlights only the URL case and is silent about city, feed, json, zone, and query, so it fails to help an agent pick among the nine optional 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 concrete outcome—HTTP status for a library docs URL—and notes the body is discarded, so it is not a pure tautology. But the term 'public library docs URL' is oddly narrow and the input schema exposes nine distinct parameters (city, feed, json, zone, query, etc.) that this description never accounts for, leaving the tool's actual scope unclear.

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

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

There is no guidance on when to prefer this tool over closely related siblings such as fetch-status, web-fetch, normalize-url, or browser-url-ok. The only implicit usage signal is the phrase 'public library docs URL', which is not enough to route an agent among the available URL/status 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 behavioral disclosure burden. It does disclose a non-obvious behavior: 'Values discarded.' But it does not say whether the count is top-level only, how invalid JSON is handled, whether input is validated, or what the return value looks like.

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

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

The description is concise and front-loaded, with no wasted words. It loses a point because its brevity omits any pointer to the confusing parameter set, which the schema does not resolve.

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

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

For a tool with 9 optional parameters, no output schema, and no annotations, this description is not complete enough. It omits how to pass the JSON object, what the result format is, whether nested keys count, and how errors or unexpected input are handled.

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 schema does not clearly map to the description. Parameters like url, city, feed, and path are unrelated to counting JSON keys, and the 'json' parameter is described as 'JSON text to validate; discarded after the check' rather than as the object to count. The description adds no parameter mapping, so an agent cannot confidently invoke the tool.

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

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

The description states a clear verb and resource: 'Count keys in a JSON object.' It also clarifies that values are discarded, which distinguishes it from validation-style siblings like validate-json. However, it does not explain how the tool relates to its 'memory' name or how the JSON object is supplied.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives such as validate-json, domain-shape, or search-query-len. The phrase 'Values discarded' weakly implies key-count-only use, but there is no when-to-use or when-not-to-use statement.

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

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

With no annotations, the description carries the behavioral disclosure burden. It does disclose one meaningful behavior—query and fragment are dropped—but it does not explain return format, error behavior, or that most of the nine optional schema parameters appear irrelevant. Behavioral transparency is adequate but thin.

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

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

The description is two short, front-loaded sentences with no filler. The operation and the key transformation are stated clearly and efficiently, so every sentence earns its place.

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

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

For a simple read-only normalizer, the description states the main output and a key transformation, but without an output schema and with a nine-parameter input schema, it leaves the return format and parameter-selection rules under-specified. This is minimally viable but has clear gaps.

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

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

Schema description coverage is 100%, so the baseline is 3; the prose adds no parameter-level detail and does not clarify which of the many optional parameters are actually relevant to normalize-url. The mention of 'query' refers to the URL component, not the schema's `query` parameter, which could cause minor ambiguity.

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

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

The description states a specific operation ('Return origin, host, and path for a URL') and names a concrete exclusion ('Query and fragment are dropped'). This clearly distinguishes what the tool produces, though it does not explicitly differentiate from sibling URL tools such as browser-url-ok or figma-url-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?

The intended usage is implied by the description: use it when you need normalized URL components. However, it provides no explicit when-to-use or when-not-to-use guidance and does not mention any alternative tools, so routing must be inferred.

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 usefully reveals that no browser is launched, which is important given the 'playwright' name, but it does not state whether a network request is made, what the return value looks like, how failures surface, or that many supplied parameters are discarded. This is too thin for an agent to predict side effects.

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

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

The description is two short sentences with no filler. The purpose is front-loaded, and the second sentence earns its place by dispelling the browser-launch assumption created by the tool name.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, the description is insufficiently complete. It does not identify which parameter actually drives the check, what the result format is, or whether external effects such as network calls occur, leaving an agent to guess at invocation and interpretation.

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 covers 100% of parameters, which normally earns a baseline of 3, but the parameter descriptions actively conflict with the stated purpose: 'url' is described as 'HTTPS URL to normalize or cite' rather than as the target of an openability check, and fields like city, json, path, zone, and query are unrelated to URL opening. The tool description adds no guidance for choosing among the nine optional 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 concrete check ('whether a URL can be opened') and a key limitation ('No browser is launched'), so it is not a tautology and is mostly clear. However, 'can be opened' is ambiguous (URL syntax, HTTP reachability, or Playwright navigability), and the description does not differentiate this from the similarly named sibling browser-url-ok.

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

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

There is no explicit guidance about when to use this tool versus alternatives such as browser-url-ok, fetch-status, or normalize-url. The negative statement 'No browser is launched' implies a lightweight check, but it does not name the alternative or specify when an agent should prefer another tool.

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

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

There are no annotations, so the description carries the full burden. It does disclose that the query is discarded, which is useful data-handling context, and 'count' implies a read-only operation. However, it does not state the return format, whether other parameters are ignored, or edge-case behavior such as empty input.

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, front-loaded sentences with no filler. Every sentence adds information: the operation and the data-discard behavior. For a tool this size, this is appropriately concise.

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

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

The tool has 9 optional parameters, no annotations, and no output schema, yet the description is only one line. It does not explain what the tool returns, which parameter is the intended search query, how to handle multiple provided parameters, or what happens when none are provided. This is incomplete for the level of ambiguity in the schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The query parameter is clearly described as 'Search text; discarded after the length check,' which aligns with the tool description. The description adds no further parameter-level meaning, and the 8 other unrelated-looking optional parameters create ambiguity that is left unresolved.

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

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

The description states a concrete operation: count characters in a search query. It names a clear verb and resource, and the second sentence clarifies that the query is not retained. However, it does not differentiate this from sibling counting tools like memory-key-count or hn-front-count, so it stops short of a 5.

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

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

The description only implies a narrow use case: needing the character length of a search query. It gives no explicit guidance on when to use this tool versus alternatives, no exclusions, and no indication of which of the 9 optional parameters should be provided. This is minimal guidance at best.

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

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

The description only says it is a 'short catalog' and gives no behavioral details beyond that. The input schema reveals many parameters (url, city, feed, json, path) that seem unrelated to HTTP status codes, and the description does not explain their role or the side effects (e.g., validation, discarding). No annotations are provided, so the description carries the full burden and fails to disclose the relevant behavior.

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

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

The description is a single short sentence with no fluff, and the core subject (HTTP status codes) is front-loaded. It is concise, though it may be under-specified for the surprising breadth of parameters in the schema.

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

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

Given the schema contains seven heterogeneous parameters (ref, url, city, feed, host, json, path) that are mostly described as 'discarded', a simple one-line description is inadequate. An agent cannot tell what the actual function is, how parameters relate to the catalog, or what the expected output looks like. The description is too sparse for the complexity hinted at by the schema.

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

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

All seven parameters have descriptive text in the schema, and the description adds no parameter-specific meaning beyond a general reference to HTTP status codes. Since the schema descriptions are reasonably clear, the baseline of 3 applies; the description neither helps nor obstructs parameter usage.

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

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

The description identifies the tool as a catalog of common HTTP status codes, which is a clear resource plus implicitly a reference/listing action. It distinguishes itself from siblings like fetch-status (which likely checks a live URL) by implying a static reference rather than a network operation.

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

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

No guidance is given about when to use this tool versus siblings such as fetch-status, compatibility, or web-fetch. The description does not mention prerequisites, typical use cases, or exclusions, leaving the agent to infer or 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?

With no annotations, the description carries the full disclosure burden. It does reveal a meaningful behavioral trait: the prompt is discarded, implying the output is fixed and not derived from the prompt. However, it does not explicitly address side effects, safety, or the lack of input-dependent behavior beyond that single phrase.

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

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

Two short sentences, front-loaded with the primary purpose, and no filler. 'Prompt discarded' is a compact caveat that earns its place. The description is appropriately concise for the small amount of information it contains.

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

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

With no output schema and no annotations, the description should explain what the template looks like or how the tool should be used. Nine parameters are optional but unexplained at the tool level, and the return value is only vaguely described as a 'three-step thinking template.' This is insufficient for confident tool selection and 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?

The schema already documents all nine parameters with descriptions, and schema coverage is 100%, so the baseline is 3. The tool description adds no additional parameter-level meaning; it only says 'Prompt discarded,' which does not map to the listed parameters or clarify how to choose among 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 specific verb and resource: 'Return a three-step thinking template.' This is not a tautology and it conveys the core function. It does not explicitly differentiate from the many sibling tools, though the 'Prompt discarded' line hints that this is not a normal processing tool.

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

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

No guidance is given about when to use this tool instead of any sibling, and there are no exclusions or conditions. The only extra information, 'Prompt discarded,' is behavioral rather than usage-oriented. An agent is left to infer why and when this tool should be selected.

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

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

No annotations are provided, so the description carries the full behavioral burden, but it only states the basic operation. It does not disclose whether the lookup is read-only, what happens for an invalid timezone name, whether a network call is involved, or what the response contains.

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

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

The description is a single, efficient sentence with no filler, and the core phrase 'current time' is front-loaded. Every word contributes to the meaning, making it appropriately concise for a simple timezone-lookup tool.

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

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

With no annotations, no output schema, and a nine-parameter schema containing many unrelated 'discarded' fields, the description is too terse to orient an agent. It should clarify that zone is the relevant input and indicate what the tool returns, since the structured data alone does not provide that context.

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

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

Schema description coverage is 100%, including the zone property described as 'IANA timezone name' and other parameters marked as discarded. The description does not add parameter-level meaning beyond the schema, so the baseline of 3 applies.

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

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

The description clearly states the operation: returning the current time for a named IANA timezone. It distinguishes itself from siblings like utc-time and iana-zones by focusing on IANA timezone lookups, though it does not explicitly name the relevant input parameter.

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

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

The description provides no guidance on when to use this tool versus alternatives like utc-time, iana-zones, or geo-hint. There are no conditions, exclusions, or pointers to more appropriate siblings, so the agent must infer usage from the tool name alone.

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

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

No annotations are present, so the description carries the full burden. It states the core behavior (returning current UTC time) but completely ignores the seven input parameters listed in the schema, which are described as discarded after checks. The description does not disclose that these parameters are irrelevant or optional, creating potential confusion.

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

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

A single, direct sentence that is front-loaded and without wasted words. It is efficient, though arguably too sparse given the complex schema it accompanies.

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 surprisingly rich input schema with detailed per-parameter descriptions, yet the one-line description does not explain why these parameters exist, whether they are optional, or how they relate to the timestamp output. Without output schema or annotations, an agent is left with significant ambiguity about the tool's actual behavior and expected inputs.

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

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

The schema provides descriptions for all seven parameters, so coverage is 100%. The description adds no parameter information beyond what the schema already states. Baseline 3 applies because the schema does the heavy lifting.

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

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

The description 'Current UTC timestamp.' concisely identifies the tool's purpose and output, clearly distinguishing it from the sibling 'timezone' tool which handles time zones. It is a clear statement of what the tool provides, though it lacks an explicit verb.

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 like 'timezone' or other time-related tools. The description gives no context for selection, leaving the agent to infer usage from the name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that the body is discarded (a useful privacy note), but it does not disclose the return value for valid/invalid JSON, error handling, or what happens with the other schema parameters. This is insufficient for a validation tool.

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

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

The description is very concise and front-loaded with the core action, and the discarding note is relevant behavioral context. However, it is almost terse to a fault, leaving out important operational details. Still, every sentence has purpose, so it earns a 4.

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 annotations or an output schema, the description must be self-sufficient. It fails to explain the return value, which parameter to pass the JSON in, or why the schema includes unrelated fields like 'city' and 'feed'. An agent would struggle to correctly invoke this tool based on this description alone.

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

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

The schema already provides descriptive text for all parameters, including 'json': 'JSON text to validate; discarded after the check', so schema coverage is high. The description does not add extra parameter meaning or clarify which field is the 'body'. Baseline 3 is appropriate because the schema does the documentation work.

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

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

The description states a specific action ('Check whether a body is valid JSON') and identifies the resource (JSON body). It is clear enough to distinguish from sibling shape-check tools like file-path-ok or browser-url-ok, though 'body' is slightly ambiguous and the tool doesn't explicitly differentiate itself from alternatives.

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

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

The description provides no guidance on when to use this tool versus other validation tools, no exclusions, and no context about typical use cases. It simply restates the function without pointing to alternatives or prerequisites.

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

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

The only behavioral detail is 'via Open-Meteo', which signals an external API call. It does not disclose return format, units, error behavior, or that several schema parameters appear unrelated and are discarded. With no annotations, the description carries the full burden but leaves much 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 focused sentence with no filler. The core action is front-loaded and every word earns its place.

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

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

Given nine optional parameters, no annotations, and no output schema, this description is too thin. It does not explain the return value, units, failure behavior, or why the schema contains so many apparently unrelated parameters. An agent could guess to provide `city`, but would be uncertain about the rest.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description indirectly points to `city` but does not explain that the other eight parameters are irrelevant to the weather result, nor does it add meaningful parameter-level detail 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 specific action and resource: 'Current temperature for a city via Open-Meteo.' It clearly conveys what the tool does and is distinct from siblings like geo-hint or timezone, though it does not explicitly distinguish itself from 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?

There is no guidance on when to use this tool versus alternatives, nor any mention of when not to use it. The description implies a weather lookup use case but provides no explicit context or exclusions.

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

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

The description discloses a meaningful behavioral trait: the body is discarded, so the tool is metadata-only. With no annotations and no output schema, it does not cover redirect behavior, response shape, rate limits, or the fact that many input parameters are effectively ignored, but it does go beyond a simple label.

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

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

Two short sentences with the primary result front-loaded and the key caveat placed right after. Every word earns its place, and there is no filler or repetition of schema 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?

With nine optional parameters, no annotations, and no output schema, the description is too thin. It does not explain which parameter drives the fetch, what the exact returned status/content-type representation is, or how to interpret the many discarded shape-check parameters. This creates real ambiguity for an agent choosing among many sibling tools.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds no parameter-level meaning beyond 'public URL' and 'body discarded', and it does not clarify whether url is the only meaningful parameter among several discard-only fields.

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

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

The description names the resource (a public URL) and the observable outputs (HTTP status and content type), and adds the key exclusion that the body is discarded. It does not use an explicit verb or name sibling differences, but the intent is unmistakable.

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

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

It clearly scopes the tool to public URLs and implies 'use this when you only need status/content-type, not page content.' However, it does not explicitly mention alternatives like fetch-status or browser-url-ok, nor does it give when-not-to-use 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?

The description does disclose that the 'title' is discarded, which is a useful lifecycle detail. But because no annotations are present, the description carries the full burden: it never states whether the check is read-only, what result is returned, or how failures or invalid titles are reported. The unrelated schema-level 'discarded' notes do not clarify the tool's actual behavior.

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

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

The description is two short sentences with no filler, and the core action is front-loaded. It is concise and readable, though the clarity is undermined by the mismatch between the stated purpose and the parameter list.

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

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

With no annotations and no output schema, the description must provide enough context to invoke the tool correctly, but it fails to do so. There is no mapping from the described title check to any parameter, no return-value information, and no explanation of the seven unrelated inputs. The definition is critically incomplete for correct use.

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 contains seven parameters—ref, url, city, feed, host, json, path—none of which represents a Wikipedia title. The description mentions a title but never identifies which parameter carries it, so the agent cannot construct a correct invocation. The schema descriptions are detailed but cover the wrong domain entirely.

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

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

The description states a specific action and resource: 'Check whether a Wikipedia title exists.' This clearly distinguishes the tool from URL, domain, or JSON validation siblings. However, it does not explicitly name alternatives, and the input schema exposes no 'title' parameter that would let an agent act on the stated purpose.

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

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

There is no guidance about when to use this tool versus alternatives such as normalize-url or browser-url-ok, and no conditions or prerequisites are given. The description only indicates what the tool does, leaving the agent to infer applicability without support.

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