ISO country KM

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

With no annotations, the description must carry the full burden of behavioral disclosure. It mentions that 'Task text discarded' and schema hints indicate parameters are 'discarded after the check', but it does not explain that the tool appears to be a static information provider that only validates input shapes. It does not disclose whether it is read-only, what happens to the parameters, or any side effects. This is a significant gap for a tool that has 9 parameters and no output schema.

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 brief (two sentences), but it is cryptic and lacks structure. The purpose is front-loaded, but the phrasing is unclear and the 'Task text discarded' clause is ambiguous. Conciseness alone is not a virtue if the content is not informative; this description is under-specified 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?

For a tool with 9 parameters, no output schema, and no annotations, the description is far too thin. It does not explain the tool's actual behavior, how the parameters are used (even though they are discarded), what the return value structure is, or how the tool fits into a workflow. The vague mention of returns is not sufficient for an agent 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?

The schema has 100% description coverage, so the parameters are individually documented in the schema. The tool description itself adds no meaning beyond what the schema provides, such as how parameters relate to the tool's function or which ones are relevant. The schema descriptions ('discarded after the check') are the only useful semantic context, but they are not reinforced or clarified in the description. Baseline 3 is appropriate 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 states a specific verb ('Find') and resource ('public pay-per-call tool gateway (Monid)'), and lists what it returns (CLI setup, how-it-works, skill file, remote MCP hops). However, 'find' is ambiguous and the description does not clarify how this tool differs from its siblings or what an agent would actually do with it. The 'Task text discarded' note adds confusion about the tool's core function.

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

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

No guidance is given on when to use this tool versus any alternative. The description does not mention any context, exclusions, or sibling tools. An agent has no basis to decide between this and the many other utility tools listed as siblings.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses only that no browser is launched, but it does not explain whether the tool makes a network request, follows redirects, what side effects may occur, what 'ok' means, 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 a single, focused sentence with no filler or repetition. It is front-loaded with the core action and the key behavioral qualifier, though it is arguably too terse for a tool with this many 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?

Given 9 optional parameters, no annotations, no output schema, and many sibling tools, this description is not complete enough. It does not explain return values, side effects, why several unrelated parameters exist, or how the agent should choose between this and similar URL-handling 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?

The input schema has 100% description coverage for all 9 parameters, so the schema already documents them. The tool description adds no parameter-level meaning, but it does not need to compensate because the schema descriptions are thorough, including which values are discarded.

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

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

The description states a clear action and resource: checking whether a URL can be opened, and adds the key qualifier that no browser is launched. This distinguishes it from browser-launching siblings like playwright-url-ok, though it does not explicitly name alternatives or define what "can be opened" means.

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 about when to use this tool versus fetch-status, web-fetch, or playwright-url-ok. The 'no browser is launched' line hints at a lightweight reachability check, but the tool does not state conditions, prerequisites, 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?

No annotations are provided, so the description must fully disclose behavior. It only says 'Expression discarded,' but no expression input exists, and it does not mention outputs, side effects, or side-effect-free guarantees.

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

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

The description is extremely short and front-loaded, but it omits essential information about the missing expression parameter and the role of the schema parameters. It is concise but not usefully structured.

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

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

With no required parameters, no output schema, and a description that does not connect the schema to the stated operation, the tool is contextually incomplete. An agent cannot determine expected inputs, outputs, or side effects.

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 have descriptions seemingly copied from unrelated tools (e.g., 'Git ref name', 'HTTPS URL to normalize or cite'). The description does not explain how any of these parameters relate to arithmetic evaluation.

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 ('Evaluate a+b style arithmetic') and resource, which appears distinct from sibling tools. However, the input schema contains no expression parameter, making the stated purpose unimplementable and 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?

The description provides no guidance on when to use this tool versus alternatives, nor any conditions, prerequisites, or examples. It is impossible to know how to invoke it correctly.

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 behavioral disclosure burden. It does disclose at least one meaningful behavioral trait—page content is not stored—and names the returned values. However, it omits context such as whether a network request is made, how redirects are handled, or why the schema accepts many seemingly unrelated optional parameters, though some of that is covered by the parameter descriptions.

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. It front-loads the primary behavior and adds a relevant privacy boundary. 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?

Given nine optional parameters, no annotations, no output schema, and a large sibling list, this description is not complete enough. It does not explain the multi-shape schema, why non-URL parameters exist, or how an agent should choose this tool over the many similar URL-related siblings. The schema covers parameters, but overall invocation context is lacking.

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 input schema already documents all nine parameters, including discard behavior for several of them. The tool description adds no parameter-level meaning beyond the schema and does not clarify that 'url' is the central parameter for the stated output.

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

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

The description states a specific verb and resource: it returns host, scheme, and HTTP status for a URL. This is clear and not tautological. However, it does not explicitly distinguish this from sibling URL tools such as normalize-url or fetch-status, and the name 'citation' does not signal this 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?

There is no guidance on when to use this tool versus alternatives. It does not mention siblings like normalize-url, fetch-status, browser-url-ok, or web-fetch, nor does it provide conditions such as 'use this when you only need URL metadata and want to avoid storing page content.' The privacy note is a hint, not a usage rule.

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

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

No annotations are provided, so the description carries the disclosure burden. The statement 'No identifiers are retained' is a meaningful behavioral/privacy guarantee, and the schema's per-parameter 'discarded' notes reinforce non-retention. However, the description does not disclose whether the tool is read-only, performs network calls, or has any side effects beyond returning a classification.

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 short and free of fluff, but the first is too vague to earn its place; 'Show how this request is classified' conveys almost no useful structure. The second sentence adds a helpful privacy note, but overall the description is under-specified rather than 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?

With nine optional parameters, no annotations, no output schema, and no explanation of the classification result, this description is far from complete. An agent cannot know what output to expect, how to interpret the classification, or which parameters create a valid request. The description needs substantially more context to be usable.

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

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

Schema description coverage is 100%, so each of the nine parameters already has a clear meaning in the schema. The main description adds no parameter-level information beyond the generic 'No identifiers are retained' assurance, which is consistent with the parameter descriptions but not needed to understand individual 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 uses a verb and a resource ('Show how this request is classified'), but 'classified' is never defined—what taxonomy, what classes, or what the output looks like. It also does not differentiate this from the many sibling shape-checking tools like domain-shape, validate-json, or normalize-url, so an agent cannot tell what 'compatibility' means.

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. The description does not mention the specialized sibling tools, nor does it state any conditions, prerequisites, or exclusions, leaving the agent to guess when 'compatibility' is the correct 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 provided, the description carries the full behavioral burden. It discloses the core behavior and one limitation (no WHOIS/ownership), but does not mention return format, error behavior, or how the many optional inputs are handled. This is acceptable for a simple read-style operation but not richly transparent.

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. It front-loads the key action and then adds the meaningful scope limitation. Every word contributes to the agent's understanding.

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

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

The tool has 9 optional parameters, no required parameters, no output schema, and no annotations, yet the description does not explain which parameter to use, what the return value looks like, or how the unrelated optional inputs should be interpreted. The presence of many 'discarded' schema parameters makes this ambiguity more significant.

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 covers 100% of the parameters with descriptions, so the baseline is 3. The tool description itself adds no parameter-specific meaning beyond the schema, and the hostname wording only loosely maps to the 'host' parameter. The schema does the necessary work here.

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'. It also adds a scoping constraint, 'without WHOIS or ownership data', which distinguishes this from domain/ownership-related sibling tools. An agent can understand exactly what operation this tool performs.

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 or when-not-to-use guidance and no named alternatives. The phrase 'without WHOIS or ownership data' weakly implies that this is for structural hostname splitting only, so usage context is implied rather than stated.

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 does disclose the HTTP method (HEAD), the target scope (public URL), and the limited return (status only). It does not cover redirects, timeouts, or response encoding, but the core side-effect profile of a read-only status probe is conveyed.

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

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

One sentence, front-loaded with the action, and no filler. It earns its place by giving the essential selection signal.

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 required parameters, no output schema, and no annotations, a single sentence is under-specified. The agent is not told which parameter is the URL to HEAD, whether the other params are alternative inputs or ignored, or what the returned status looks like.

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

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

Schema description coverage is 100%, so the baseline applies; the tool description adds no parameter-level semantics. The url parameter's schema text ('HTTPS URL to normalize or cite') actually sits oddly with the description's HEAD claim, but the schema itself documents each parameter.

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

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

The description names a specific verb (HEAD), a resource (public URL), and a narrow output (status only), which separates it from content-fetching tools like web-fetch. However, it does not address the other eight optional parameters in the schema, so the tool's full scope is 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?

'Return status only' implies a lightweight check and hints not to use it when a page body is needed, but it never names an alternative or states a when-not-to-use condition. With many siblings including browser-url-ok and playwright-url-ok, the lack of explicit routing guidance leaves selection to inference.

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

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

With no annotations, the description carries the burden and does disclose one non-obvious behavior: the path is discarded. However, it does not state whether the operation is purely local, what happens on invalid/non-Figma URLs, 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?

Two short sentences with no filler, and the purpose is front-loaded. The phrase 'Path discarded' is terse and slightly ambiguous, but 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?

The tool has no output schema and no annotations, yet the description never explains the return value, error behavior, or parameter selection among nine optional fields. An agent could guess it takes a URL, but it cannot tell what result to expect or how to invoke it reliably.

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

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

Schema description coverage is 100%, so the baseline is 3 and the schema already documents each parameter. The description adds a small amount of meaning by narrowing the URL to Figma file URLs, but it does not clarify which of the nine optional parameters to supply or how the extras are treated.

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?

Description uses a specific verb ('Parse') and a specific resource ('Figma file URL'), so an agent can tell it apart from sibling shape tools like github-repo-shape or jira-key-shape. The second sentence adds a concrete boundary: the path is discarded.

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 a clear use context: when a Figma file URL needs to be parsed. It does not mention when not to use it or name alternatives among the URL-related siblings, so it stops short of full routing guidance.

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

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

With no annotations, the description carries the full burden. It discloses the key side-effect-free behavior ('No disk access') but does not define what 'looks safe' means, what the return value is, or how invalid paths are handled. It provides some useful behavioral context but remains 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 extremely concise, with no filler or redundancy. The safety qualifier is front-loaded. However, it is so brief that it leans toward under-specification rather than ideal conciseness.

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

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

The tool has no annotations and no output schema, while the description fails to define safety criteria, return format, or parameter selection. With a crowded sibling set and a 9-parameter schema containing off-topic fields, an agent cannot reliably determine when and how to 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 schema already documents each parameter. The description adds no parameter-level meaning beyond naming 'a path', and the schema includes many unrelated properties (url, city, feed, host, json, zone, query), creating ambiguity about which parameter is actually 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 ('Check') and resource ('a path'), with a safety qualifier ('looks safe'). It is clearly differentiated from sibling tools like browser-url-ok and wiki-title-ok by focusing on file paths rather than URLs or titles.

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 explicit when-to-use or alternative tool guidance is provided. 'No disk access' implies a lightweight validation context, but the description never states when to prefer this tool over siblings or what conditions make it inappropriate.

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 the external Open-Meteo dependency, which is useful, but it does not clarify that most of the nine parameters appear to be local shape-check/discard fields and that only a place/city input triggers the geocoding.

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, which is concise. However, for a tool with nine parameters and no annotations, it is arguably too sparse to be fully '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 the complex, decoy-heavy schema and no output schema, the description is incomplete. It does not tell the agent which argument selects the place, what a valid invocation looks like, or how to ignore the unrelated parameters, so a caller could easily pass the wrong field.

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

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

Schema coverage is 100%, so the baseline is 3. The description does not add parameter-level meaning: it never maps 'a place' to the city property, leaving the eight unrelated-looking parameters unexplained. The schema's per-parameter 'discarded after...' descriptions carry the real weight here.

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 core resource (latitude/longitude) and the service (Open-Meteo), making it reasonably clear what the tool produces. It distinguishes geo-hint from weather-related siblings by focusing on coordinates rather than weather, though it lacks an explicit verb like 'returns' or 'looks up'.

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 guidance, no mention of alternatives, and no exclusions such as 'if you only need weather, use weather-hint instead.' The intended use is only implied by the phrase 'for a place.'

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

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

With no annotations, the description carries the full behavioral burden, yet it describes only the GitHub URL path. The schema reveals the tool accepts eight other unrelated inputs (city, feed, json, path, host, query, ref, timezone) with 'discarded after' semantics, which the description omits entirely. The description presents a narrow parser while the schema shows a multi-purpose shape-checker.

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 single sentence is efficient and front-loaded, but it is under-specified for a tool whose schema covers nine unrelated input types with side effects (discarding). It earns credit for brevity but loses credit for not representing the tool's actual scope.

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, zero annotations, and no output schema, a one-sentence description is insufficient. An agent cannot tell what the tool returns, how the nine parameters relate to one another, or whether GitHub parsing is the only behavior versus one branch of a generic validation dispatcher.

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 fully documents all nine parameters including their discard behavior. The tool description adds no per-parameter meaning beyond tying the purpose to the url parameter, which matches the baseline for full 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 names a specific verb ('Parse') and resource ('GitHub URL') with an explicit extraction target ('owner and repo'). The resource type differentiates it from sibling shape tools like figma-url-shape and jira-key-shape without needing to open their schemas.

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

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

The description implies when to use it — whenever a GitHub URL needs owner/repo extraction — but it never states when not to use it or names alternatives such as normalize-url, figma-url-shape, or domain-shape. The usage context is inferable but not explicit.

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

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

With no annotations, the description carries the behavioral burden. It does disclose one useful behavior: titles are discarded, so the output is a count rather than a list of titles. However, it does not mention network access, failure modes, or the exact return format, leaving some behavioral context unstated.

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

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

The description is only two short sentences, with the core action front-loaded. 'Titles discarded' adds a relevant behavioral note without unnecessary padding or repetition.

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 count tool, the core operation is clear, but the presence of nine optional, mostly unrelated parameters and the absence of an output schema leaves ambiguity about invocation and expected return shape. A brief statement such as 'No input required' or 'Returns a number' would make it fully complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself adds no parameter-level meaning and does not clarify whether any of the nine optional parameters should be supplied or ignored, though the schema documents each parameter individually.

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

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

The description names a specific action ('Count') and a concrete resource ('current Hacker News front-page stories'), making the tool's purpose clear. The detail 'Titles discarded' further clarifies that the result is count-only, distinguishing it from fetch or search tools that would return content.

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

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

No guidance is provided about when to use this tool versus alternatives such as web-fetch or fetch-status. The description implies a use case but does not state exclusions, prerequisites, or when another 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.

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

No annotations are present, so the description carries the full transparency burden. It implies a read-only catalog of timezone names but does not disclose output format, side effects, error behavior, or the fact that several input parameters are described as discarded. The agent is left to infer most 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 a single short sentence with no filler, so it is concise. However, it is concise at the expense of completeness: it lacks a verb, an action, and any usable operational detail, making it under-specified rather than appropriately compact.

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 annotations, and no output schema, this tool needs a substantive description. The one-sentence phrase does not explain how to invoke the tool, what the parameters do, what the response contains, or how it fits with the sibling tools, leaving the agent unable to call it correctly with confidence.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the tool description adds no parameter-level detail. The description does not explain how parameters like ref, url, city, or json relate to IANA timezone names, and the schema's own parameter descriptions are confusing because they seem unrelated to 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 is a noun phrase rather than a statement of what the tool does; it never says whether the tool returns, lists, or validates IANA timezone names. 'Common IANA timezone names for clock calls' mostly restates the tool name and adds only a vague use-case hint, so it does little to distinguish this tool 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 such as timezone, utc-time, or other hint tools. 'For clock calls' hints at a context but does not define what clock calls are, what prerequisites exist, or when this tool should not be used.

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 clearly states a read-only fetch and that only group counts are returned, which is useful behavioral context. With no annotations provided, it partially carries the transparency burden, but it does not mention failure behavior, redirects, rate limits, or what happens when the robots.txt is missing.

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

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

The description is a single front-loaded sentence with no filler. It communicates the core action and return scope efficiently, though it is terse enough that important usage and parameter mapping details are 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?

For a tool with 9 optional parameters and no output schema or annotations, this description is under-specified. It does not explain which parameter to provide, what 'group counts' means structurally, or how the sibling tools differ, leaving an agent with significant ambiguity.

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

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

Schema description coverage is 100%, so parameters have individual descriptions and the baseline is 3. The main description adds no mapping between its 'robots.txt' fetch intent and the provided params (url vs host), leaving some ambiguity about which parameter is actually used.

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

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

The description names a specific verb and resource: fetch a public robots.txt and return group counts. This distinguishes it from generic fetching tools like web-fetch. However, it does not explicitly mention which parameter supplies the target URL, so the purpose is clear but slightly incomplete.

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 siblings such as web-fetch, fetch-status, or normalize-url. There is no stated context, alternatives, or exclusions, so the agent must infer appropriate 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?

The description discloses a behavioral trait by saying the key is discarded, which is useful privacy/retention context. However, there are no annotations to carry the safety burden, and the description does not explain the check's output, side effects, or error behavior, so full transparency is still missing.

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 core action first and the discard behavior second. There is no filler, and each sentence contributes a distinct piece of information, though the brevity borders on 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?

For a tool with seven parameters, no annotations, and no output schema, a two-sentence description is insufficient. It never states the required parameter, the expected Jira key format, or what the tool returns, so an agent cannot confidently 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 high with descriptions for every parameter, so the baseline is 3. However, the description itself does not identify which parameter should hold the Jira key, and the schema parameter meanings are generic (git ref, URL, city, feed, host, JSON, path), leaving uncertainty about how to invoke the tool correctly.

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

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

The description states a specific action and resource: check a Jira issue key's shape. This is enough to distinguish it from domain-shape, github-repo-shape, or figma-url-shape by topic, though it does not name any sibling tool explicitly.

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 validate-json, wiki-title-ok, or the other shape-checking siblings. The tool name and one-line purpose imply a use case, but the description gives no context about when this check is appropriate or when an alternative should be preferred.

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

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

The description does disclose that the body is discarded, which is a small behavioral detail. It does not mention whether a network request is made, redirects, timeouts, or error handling, so it does not fully carry the transparency burden.

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

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

The description is extremely short and front-loaded, with the output type in the first words.

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 and no output schema, the description is too thin to tell an agent how to construct a valid call or interpret the response. It does not specify return format beyond 'HTTP status' or explain what to do with the many discarded parameters.

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

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

Each parameter has a one-line description, but several are explicitly marked discarded (ref, city, feed, query, etc.), and the only apparently relevant parameter, 'url', is described as 'to normalize or cite' rather than 'to check'. This makes it unclear which of the nine optional parameters actually affect the result.

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 output (HTTP status) and the target (a public library docs URL), and notes that the body is discarded. However, it does not use an explicit verb like 'check' or 'fetch' and does not differentiate itself from sibling URL-status tools.

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

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

No guidance is given about when to prefer this tool over fetch-status, browser-url-ok, or normalize-url. The only implicit hint is that it focuses on HTTP status and discards the body.

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. 'Values discarded' is a useful trait because it tells the agent the tool will not preserve or return values, and 'count' implies a read-only action. However, it does not mention error behavior, whether nested keys are counted, return format, or any 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?

Two short sentences with no filler. The core verb 'Count' is front-loaded, and 'Values discarded' is a compact additional constraint that 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?

Despite the simplicity of the one-line description, the tool has 9 optional parameters, no output schema, and no annotations. The description does not state what the tool returns, which parameter should hold the JSON, how invalid JSON is handled, or whether the count includes nested keys, leaving too much unspecified for reliable 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 has 100% parameter description coverage, so the schema already documents each parameter. The tool description does not add meaningful parameter semantics beyond saying 'JSON object', which loosely aligns with the json parameter, but it does not clarify the role of the many other unrelated parameters.

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

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

The description states a clear operation: count keys in a JSON object, and explicitly says values are discarded. This distinguishes it from validation-focused siblings like validate-json, though it does not name any sibling or explain scope more precisely.

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

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

No guidance is given about when to use this tool versus alternatives. It does not mention which sibling to prefer for validation, shape checking, or other JSON-related tasks, so the agent has to infer usage from the tool 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?

The description discloses a key behavior ('Query and fragment are dropped') and the return content, but with no annotations it leaves other behavioral traits unstated, such as whether any validation occurs, whether network access is involved, or how invalid URLs are handled.

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

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

The description is two short sentences with no filler. The main purpose is front-loaded and the dropping behavior is stated directly.

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 a confusing nine-parameter input schema, the description is not enough context. It does not specify the return format, which parameters are actually needed, error behavior, or why most of the declared parameters are present.

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 every parameter has a schema description, most are unrelated to URL normalization (e.g., 'Git ref name', 'City name', 'IANA timezone name'), and the description does not clarify why they exist. It only implicitly covers 'url' and 'query', but even 'query' conflicts with the schema description of 'Search text; discarded after the length check'.

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

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

The description states a specific action ('Return origin, host, and path') and input ('for a URL'), and clarifies that query and fragment are dropped. This clearly distinguishes it from sibling tools like browser-url-ok or fetch-status, which check availability or status.

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

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

No guidance is given about when to choose this tool over alternatives, and no sibling tools are referenced. The description only says what it does, not when it should be used.

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 alone must disclose side effects and behavior. It does state that no browser is launched, which is useful, but it fails to explain what 'can be opened' means operationally: whether a network request is made, what is checked, whether data is fetched, or whether any state changes occur. Given the tool has nine parameters and several 'discarded after' behaviors, the description is too thin.

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

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

The description is a single, front-loaded sentence with no filler. Both statements are meaningful: the tool's action and a key behavioral constraint. This is concise without sacrificing 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?

While the schema covers parameters and the description gives the primary purpose, the tool has no output schema and no annotations. It does not describe expected outcomes, failure conditions, or how to interpret the result. The large set of auxiliary parameters also makes the overall context incomplete without more explanation about why they are accepted or how they influence the check.

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 every parameter. The description adds minimal value by connecting the 'url' parameter to the main purpose, but it does not explain the roles of the other eight parameters or how they relate to the URL check. Baseline 3 is appropriate because the schema carries the parameter documentation burden.

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

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

Description states a specific verb ('Check') and resource ('whether a URL can be opened'), and adds a distinguishing behavioral note ('No browser is launched') that separates it from sibling tools like browser-url-ok. This clearly identifies the tool's core function.

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 a lightweight check that does not launch a browser, which offers some context for when to choose it over heavier browser-based tools. However, it does not explicitly state when to use this tool versus alternatives such as browser-url-ok, fetch-status, or normalize-url, leaving usage guidance mostly implicit.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It does disclose one trait: 'Query discarded' indicates the input is not retained or returned. But it says nothing about what the tool returns (a number? a status?), how it handles the other eight parameters, what happens if multiple parameters are provided, or whether the operation is read-only. These gaps are significant for a tool with such a broad parameter surface.

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 consists of two short sentences with no filler. The primary purpose is front-loaded, and the second sentence adds a useful behavioral note without redundancy. Every word contributes meaning, making it an excellent example of 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?

Despite a 9-parameter schema, no output schema, and no annotations, the description offers only a bare statement about counting characters in a search query. It does not explain the relationship among the 9 parameters, which one is the 'search query,' whether they are mutually exclusive, what the return shape is, or what side effects occur. An agent would be left guessing how to call the tool correctly for anything other than the simplest single-query use 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 tool description adds no parameter-specific value beyond reinforcing that the 'query' parameter is a search text that gets discarded. It does not clarify whether the other parameters are alternatives, ignored, or also subject to counting. Since the schema already documents each parameter's own role, the description neither improves nor detracts from parameter understanding.

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

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

The description states a specific verb and resource: 'Count characters in a search query.' This clearly distinguishes the core action from sibling count tools like memory-key-count or hn-front-count. However, the schema exposes 8 additional parameters (URL, city, feed, host, JSON, path, zone) that are not mentioned in the description, leaving ambiguity about whether the tool can also operate on those inputs. Thus it is clear but not fully unambiguous.

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

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

The description implies when to use the tool: when you need the character count of a search query. But it provides no explicit guidance about alternatives, no exclusions, and no mention of when to prefer another tool. The sibling list includes several shape/check tools, but the description does not address them. Usage must be inferred from the purpose statement rather than being explicitly stated.

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 labels the content as a 'short' catalog and never explains what happens with the supplied inputs, whether they filter the catalog, or what the output looks like. This is far too little for a tool with seven parameters.

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

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

The description is a single short sentence with no filler, so it is concise in form. However, it is under-specified for a tool with seven heterogeneous parameters and no annotations or output schema. This brevity is a gap in specification rather than an example of 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 tool has no annotations and no output schema, so the description is the sole source of contextual information. It fails to mention the output format, how the parameters affect results, or any invocation constraints. This is completely inadequate for a multi-parameter tool.

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

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

Every parameter has a description in the input schema, so schema description coverage is high and the baseline is 3. The tool description adds no parameter-level meaning and does not clarify how the parameters like ref, url, city, and path relate to the catalog. Since the schema already documents each parameter individually, no further penalty is applied.

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 that essentially restates the tool name: 'Short catalog of common HTTP status codes' is another way of saying 'status-catalog'. It names the resource but lacks a verb that tells an agent what operation the tool performs or what it returns. It also does not differentiate the tool from sibling tools like fetch-status.

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

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

There is no guidance about when to use this tool versus alternatives. The description does not mention fetch-status, validate-json, or any other sibling, nor does it state the conditions under which status-catalog should be selected. With seven heterogeneous input parameters and no usage context, an agent cannot infer appropriate invocation.

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

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

The description adds a useful non-obvious behavior: Prompt discarded, meaning the input will not affect the result. However, with no annotations, it does not further disclose whether the output is deterministic, whether the call has side effects, or how the nine parameters are handled beyond the schema descriptions.

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

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

Two short sentences with no filler, and the key caveat about the discarded prompt is stated directly. The description is appropriately concise for a simple template-returning tool, though it could be slightly more informative without losing brevity.

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 schema already documents all optional parameters and their disposal behavior, and the description states the prompt is ignored. Still, the description does not say to invoke the tool with no arguments, describe the returned template format, or explain when to choose this tool over sibling tools, leaving some context missing.

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

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

All nine parameters already have complete schema descriptions, including the fact that each is discarded after its shape check, so the description does not need to add parameter meaning. The tool description contributes no new semantic detail beyond that 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 gives a clear verb and object: return a three-step thinking template, and it explicitly notes that the prompt is discarded. This differentiates it from the sibling validators and shape-checkers, though it does not name an alternative or detail what the template contains.

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?

Usage is only implied: call it to obtain a fixed thinking template, and the prompt will not be used. There is no explicit when-to-use guidance, exclusion, or comparison with alternative tools, so an agent must infer the appropriate call context.

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 of behavioral disclosure. It mentions only the basic function and does not describe output format, timezone validation, or potential errors. For a simple read tool this is minimal but not enough to fully inform the 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 a single, concise sentence with no filler and places the core action first. It is appropriately brief for a simple tool, though the brevity omits some useful context.

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

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

With no output schema and no annotations, the description should clarify the return format and how the timezone is specified, but it does not. The tool is simple, but the lack of usage or output details leaves it incomplete.

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

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

Schema description coverage is 100%, so parameter meanings are already documented in the schema. The description does not add parameter-specific guidance, but the baseline of 3 applies because the schema covers the parameters.

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

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

The description clearly states the operation: retrieving the current time, and the resource: a named IANA timezone. This distinguishes it from related siblings like utc-time and iana-zones, though it does not explicitly name 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 is provided on when to use this tool versus alternatives such as utc-time or iana-zones. The description only defines what the tool does, leaving selection criteria up to the 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?

With no annotations, the description carries the full behavioral burden, but it only states the output. It does not disclose that the many schema parameters are ignored or discarded, which is especially relevant given the seemingly unrelated input schema.

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

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

The description is one short sentence with no filler and the core information front-loaded. It is concise without being padded.

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

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

The description is sufficient for a trivial timestamp retrieval, but the presence of seven unrelated parameters creates ambiguity that the description does not resolve. A brief clarification that no arguments are needed or that all inputs are discarded would make it complete.

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

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

All seven parameters already have descriptions in the schema, so the baseline is 3. The description adds no parameter-level meaning, but it is not required to repeat schema details; the gap is that it does not explain why a timestamp tool accepts these 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 the tool's output as a current UTC timestamp, which is specific enough to identify the resource. It is distinguishable from the sibling 'timezone' tool, though it lacks an explicit verb phrase.

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 rather than available alternatives. It does not mention 'timezone' or any other sibling, and no selection conditions are provided.

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

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

With no annotations, the description carries the burden of disclosing behavior. It explicitly notes that the body is discarded, which is useful, but it does not disclose return behavior, error handling, or whether external calls are involved.

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. Both the purpose and the behavioral note earn their 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 tool with seven parameters, no annotations, and no output schema, one sentence is too thin. It does not state the result value, error behavior, or that only the `json` parameter matters, leaving the 'body' reference ambiguous.

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

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

The input schema already describes all parameters, including `json` as the text to validate, so the baseline is 3. The description adds no clarification about which of the seven parameters should be used for the body.

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: checking whether a body is valid JSON. This distinguishes it from sibling validators like domain-shape and file-path-ok, though 'body' is not explicitly mapped to the `json` 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?

No guidance is given on when to choose validate-json over sibling validation tools, and there are no conditions, exclusions, or alternatives. Usage is only implied by the tool's name and action.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the data source (Open-Meteo) but not what the tool returns, whether it makes a network request, or that most schema parameters are discarded after a shape check. The schema descriptions reveal this discarded-parameter behavior, but the main description fails to communicate it to the 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 a single, efficient sentence with no filler or repetition. It front-loads the purpose and provider. However, it is so terse that it omits important behavioral context, so it earns a high conciseness score but not a perfect one.

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, no annotations, and a schema containing many seemingly unrelated fields, the description is insufficiently complete. It does not clarify which parameters are actually used, what the output looks like, or why fields like 'ref', 'feed', and 'host' are present. An agent could be confused about whether those fields influence the weather 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 each parameter already has a documented meaning, including the 'discarded after' behavior. The description adds minimal value beyond identifying 'city' as the relevant weather parameter. Given the high schema coverage, a baseline of 3 is appropriate; the description does not need to repeat parameter details.

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 core function: returning the current temperature for a city via Open-Meteo. It uses a specific resource (city weather) and provider, which distinguishes it from sibling tools like geo-hint. However, it does not explain that several input schema fields are intentionally discarded as 'hints' unrelated to weather.

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, nor any mention of prerequisites or exclusions. The description implies it should be used for current city temperature, but it never states a decision rule or names sibling tools for comparison. This is essentially no usage guidance beyond the bare 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?

With no annotations, the description carries the transparency burden. It discloses a key behavioral trait: the response body is discarded, so only status and content type are returned. It also scopes input to public URLs, implying no authentication, but it does not mention redirect behavior, timeouts, or error response handling.

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: it states the purpose in the first sentence and adds the key behavioral caveat in the second. There is no filler or redundancy.

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

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

The definition is incomplete given the tool's complexity: nine optional parameters, no annotations, no output schema, and a description that only covers URL fetching. An agent cannot confidently determine which parameter to supply, what the response structure looks like, or how unrelated parameters will be 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 description coverage is 100%, the parameter descriptions conflict with the tool's stated purpose. Most parameters refer to unrelated concepts like git refs, city names, JSON validation, or timezones and are 'discarded after the shape check,' while the description only discusses fetching a URL. The description does not clarify that only the 'url' parameter is relevant, leaving the input contract ambiguous.

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

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

The description clearly identifies the tool's function: retrieving HTTP status and content type for a public URL, with the body discarded. This distinguishes it from tools that return full content or perform other URL operations, though it does not explicitly name a sibling alternative.

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 siblings like fetch-status, browser-url-ok, or normalize-url. It implies use for public URLs and header-only checks via 'Body discarded,' but it never states exclusions or recommends 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?

No annotations are provided, so the description carries the behavioral burden. It discloses one useful privacy trait: 'Title discarded after the call.' However, it does not describe return shape, failure behavior, or network dependency, so transparency is partial.

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

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

The description is short and front-loaded with the tool's purpose, followed by a one-sentence behavioral note. Besides the confusing 'title' reference that is missing from the schema, the text is efficient and appropriately sized.

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

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

The definition is not complete enough to invoke correctly: there are no annotations or output schema, and the description never maps the tool's stated purpose to any of the seven input parameters. The schema's unrelated parameters and absent title field leave a critical 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?

The schema contains seven string parameters with individual descriptions, but none corresponds to a Wikipedia title. Several are explicitly marked 'discarded' or describe unrelated concepts like weather hints, Git refs, and RSS feeds. The description gives no hint how to supply the title, so an agent cannot determine a valid invocation.

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

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

The description states a specific action and resource: 'Check whether a Wikipedia title exists.' This is clear and distinct from sibling tools like domain-shape or github-repo-shape. The second sentence about discarding the title does not obscure the core purpose.

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

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

The purpose statement implies when to use the tool: when an agent needs to confirm whether a Wikipedia title exists. However, it never explicitly states usage context, exclusions, or alternatives among the many sibling tools, so the guidance is only implied.

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