UUID v7 time-sortable shape

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

With no annotations present, the description carries some behavioral burden. It does disclose that 'Task text discarded,' which is a meaningful privacy/disposal trait, and it says it returns connection methods. However, it does not describe other behavioral aspects like permission needs, rate limits, or side effects, and the step-by-step disposal is mostly left to the parameter 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 short, front-loaded with the main purpose, and all three sentences add information. The line 'Task text discarded' is a little cryptic and not directly tied to any schema property, but overall the size and ordering are reasonable.

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 is not sufficient. It never explains what actually causes the tool to match one param or task to a gateway, how the provided parameters map to the tool selection, or what shape the returned connection methods take. The description would need substantially more detail to allow 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 parameter descriptions already provide 100% coverage for the 9 optional properties, so the baseline is 3. The tool description itself adds no additional parameter-level meaning beyond the schema's 'discarded after...' notes and does not explain how the many disjoint parameters (ref, url, city, path, zone, etc.) should be combined or which ones are relevant to a task. It meets the baseline for schema coverage but adds no extra semantic clarity.

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

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

The description uses a specific verb and resource: it 'Find[s] a public pay-per-call tool gateway' and 'Returns connection methods.' This makes the core purpose understandable. However, it does not explicitly distinguish itself from sibling tools like weather-hint or search-query-len, which are also task-oriented, so it is clear but not fully differentiated.

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 siblings, no preconditions, and no listed alternatives. It only implies you would use it when you need a gateway for a task, but never states that explicitly or what inputs to supply. This leaves the agent to infer usage.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does state the no-browser behavior and says it's a check for whether the URL can be opened, but it gives no detail about the network access, timeout, redirects, or how the result is returned (boolean? status code?). With 9 parameters including city/json/path/zone, it does not explain how these are treated or conflict with the url-only focus. This is a significant gap for a tool with zero annotation coverage.

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

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

The description is a two-sentence, front-loaded with the purpose and the key non-browser trait, with no redundant phrases. It is compact and immediately readable. Structure is optimal for the information provided.

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

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

The tool has 9 optional parameters and no output schema, no annotations. The description only covers a single URL check, leaving the role of the other 8 parameters unexplained, and it does not describe return values or behavior beyond the check. Given the schema's complexity, the description is too thin to tell an agent how to supply the correct input or interpret the result. The discarding notes in schema descriptors are not sufficient to make the tool 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 the baseline is 3. The tool description adds no meaning beyond the schema — it doesn't mention which parameters to use, that the others are discarded, or why they are present. The schema descriptions already say some params are discarded, but the description doesn't reinforce, so no value is added. The description's value is neutral.

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: 'Check whether a URL can be opened.' The 'No browser is launched' clause distinguishes this tool from browser-based alternatives like playwright-url-ok, providing purpose clarity beyond just restating the name. However, the purpose is not narrowed to a single parameter, and the existence of 8 other input params creates ambiguity about what the tool actually operates on.

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 includes 'No browser is launched,' which labels when to use the tool versus a browser-based sibling, but it does not explicitly state alternatives or conditions. There is no mention of when to use this tool over web-fetch, normalize-url, or the other shape types in the schema, and no guidance about which parameters to provide. It would be an implicit hint for a browser test, but not clear, so usage guidance is minimal.

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 does disclose that the expression is discarded, but it does not say what the tool returns, whether it is read-only, how invalid inputs behave, or how the unrelated parameters are processed beyond what the schema already states.

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

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

The description is short, but it is under-specified rather than efficiently concise. Two sentences are not enough for a nine-parameter tool with no annotation support, and the wording does not front-load the input/output relationship.

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 parameters, no annotations, no output schema, and many sibling alternatives, the description is highly incomplete. It never connects the parameters to the advertised arithmetic behavior, describes the return shape, or explains how an agent should structure a valid call.

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 extra parameter meaning and does not reconcile 'a+b' with any property in the schema, but the individual parameter descriptions already give thorough semantic 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 an action ('evaluate a+b-style arithmetic') rather than being a pure tautology, but it does not map to the nine parameters, none of which is an arithmetic expression, and additionalProperties is false. An agent cannot tell what input actually satisfies 'a+b style arithmetic', so the stated purpose is misleading in practice.

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, when not to, or how it differs from the many sibling check/shape tools. The phrase 'Expression discarded' is behavioral, not directional, so the agent gets no selection support.

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

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

No annotations are present, so the description bears the full disclosure burden. The only added behavioral fact is 'Page content is not stored,' which is useful but leaves out rate limits, caching, redirect/error handling, side effects, and what actually happens with the eight unrelated parameters. The 'discarded after check' statements live in the schema, not the description, so they earn no credit here.

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

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

Two sentences with zero fluff and the main capability is front-loaded. The brevity is economical, though it is also why the description lacks parameter mapping and usage context that the tool otherwise needs.

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

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

For a tool with nine optional parameters, no output schema, no annotations, and 28 siblings, the description is under-specified. It doesn't state which parameters produce the outcome, what the return format is, or how the 'discarded after check' parameters are handled at the tool level. Only the trivially simple single-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 coverage is 100%, so the baseline is 3, but the description adds no meaning to the nine parameters while most of them (ref, city, feed, json, path, zone, query) look entirely unrelated to 'host, scheme, and HTTP status.' An agent cannot tell whether only url is needed or how the remaining parameters influence the output, which makes the description actively misleading for parameter selection.

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

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

The description uses a specific verb ('Return') with a concrete resource combination (host, scheme, HTTP status) and adds a distinctive privacy caveat (content not stored). However, it does not differentiate this tool from heavily overlapping siblings such as fetch-status and normalize-url, and the tool name 'citation' does not obviously map to 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?

No guidance is given about when to use this tool versus siblings like fetch-status, normalize-url, or web-fetch. There are no prerequisites, exclusions, or conditions mentioned, so with a sibling list of 28 tools the agent has no basis for selecting this one over the overlapping 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?

The privacy statement 'No identifiers are retained' is a useful behavioral disclosure, and the schema descriptions for parameters extend it with individual discard and 'no disk access' promises. However, with no annotations, the description alone does not disclose operational side effects, authentication needs, return values, or whether any network activity occurs.

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

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

Two sentences: the first states the purpose, the second adds a key privacy caveat. There is no fluff or redundancy, and the description stays appropriately short even with nine parameters.

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

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

With nine optional parameters, no output schema, and no annotations, the description is far too terse. It does not state whether one or more parameters should be supplied, what the classification categories are, what 'show' returns, or how to retrieve results. The agent cannot invoke this confidently from the description alone.

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

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

The schema already gives 100% coverage by describing all nine parameters (e.g., 'discarded after shape check', no disk access). The main description adds no parameter-level meaning beyond generic 'request' wording, so the baseline schema coverage justifies a score of 3.

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

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

The description states a specific action ('Show how this request is classified') but never explains what 'request' refers to or what classification means. It does not distinguish itself from sibling tools like browser-url-ok or normalize-url, and the tool name 'compatibility' only adds ambiguity.

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

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

There is no guidance on when to use this tool, when not to, or which sibling tool it replaces. The sentence 'Show how this request is classified' implies a diagnostic use case, but leaves the agent to guess what input to supply and what the classification output is for.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses a partial behavioral boundary by excluding WHOIS/ownership data, but it does not state whether the operation is strictly local/read-only, what happens for invalid hostnames, how output is returned, or whether any hidden side effects exist.

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 words, and the negative qualifier about WHOIS/ownership data earns its place. It is concise but does not go further to make up for the missing usage or behavioral 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 9 optional parameters, no output schema, and no annotations, the description is too thin for a tool an agent must invoke correctly. It does not explain which parameter is the actual input, what the split result looks like, or how invalid hostnames are handled, leaving meaningful 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?

The input schema already documents all nine parameters well, so the high coverage baseline is 3. The description adds only the notion that a hostname is split into labels, and it does little to help the agent identify that the relevant argument is 'host' among many mostly unrelated 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 clear action and resource: split a hostname into labels. It also adds a useful negative boundary by saying the tool does not involve WHOIS or ownership data, though it does not explicitly differentiate from sibling shape tools such as normalize-url or github-repo-shape.

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

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

There is no guidance on when to use this tool versus alternatives like normalize-url, browser-url-ok, github-repo-shape, or other shape-focused siblings. The description implies a pure lexical operation, but it does not state which inputs to prefer, what conditions make this tool appropriate, or when to use 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?

No annotations are present, so the description must carry the behavioral burden. It usefully reveals that the operation uses HEAD and returns status only, implying a non-mutating, minimal-transfer call. However, it does not describe what happens for non-URL parameters, error behavior, or the 'discarded after' semantics that appear in the 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 a single short sentence with no filler, front-loading the headline operation. It is appropriately concise, though it may be too brief relative to the complexity implied by the 9-parameter 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 annotations, no output schema, and a 9-parameter input schema, the description must be far more detailed to be contextual. It does not specify the return format, error behavior, or what status means for the various accepted inputs, leaving the agent with an incomplete picture.

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

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

Schema description coverage is 100%, and each parameter has its own semantic description, so the schema does the heavy lifting. The tool description adds no parameter-level meaning and especially does not explain how nine unrelated parameters plus a HEAD check on a public URL interact.

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 HTTP method (HEAD), a target resource (public URL), and the output (status only), which is clear and not a mere restatement of the name. It does not use the sibling tool names to differentiate, and the later schema introduces many unrelated parameters, so the purpose is clear but not fully aligned with the schema scope.

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

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

There is no guidance on when to use this tool versus alternatives such as browser-url-ok, playwright-url-ok, or web-fetch. No prerequisites, exclusions, or conditions are given, leaving the agent to guess from the schema and sibling list.

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

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

No annotations are provided, so the description carries the full burden of explaining behavior. 'Path discarded' gives one concrete trait, but it does not say whether the operation is read-only, what validation or parsing rules apply, what the return value looks like, or whether the URL is network-accessed. The word 'Path' is also ambiguous because the input schema includes a `path` parameter and a `url` parameter.

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

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

The description is short and has no filler, which is good, but it is too terse to be genuinely well-structured. The sentence 'Path discarded.' is ambiguous and does not earn its place because an agent cannot tell if it refers to a URL path, a file path, or the schema's `path` parameter.

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 parameters, no output schema, and no annotations, a two-sentence description is not enough to invoke the tool correctly. The sibling tool list contains several similar URL/shape handlers, and nothing in the description tells an agent what result to expect or which parameters should be supplied together.

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 remains 3. The description adds only the Figma-URL qualifier and implies the `url` parameter matters, but it fails to clarify the role of the other 8 optional parameters or why a shape-like figma-URL tool accepts such unrelated fields.

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

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

The description names a specific verb and resource: 'Parse a Figma file URL.' It is reasonably distinct from sibling tools like normalize-url or browser-url-ok because it targets Figma URLs specifically. The added 'Path discarded' gives a small behavioral hint, though it is not enough to fully separate it from all related URL/shape tools.

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

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

There is no guidance about when to use this tool versus the many nearby URL, shape, and validation siblings. No prerequisites, exclusions, or alternative tool names are mentioned, so the only usage signal is a vague inference from 'Parse a Figma file URL.'

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 and no output schema, the description carries the full burden of behavioral disclosure. It discloses only that there is no disk access, omitting what makes a path 'safe', what is returned, and whether inputs other than `path` are handled or 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 concise and front-loaded: a one-line primary purpose followed by a single clarifying behavioral note. Every word earns its place with 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?

Even for a simple checker, the description is incomplete against the rich context: nine optional parameters, no output schema, and no annotations. It fails to say what a 'safe' path is, what response format to expect, or which of the nine fields should be supplied.

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 even though the description adds nothing about parameters. The description only singles out 'path', while the other schema fields (ref, url, city, zone, json, query) are left unexplained in relation to the tool's purpose.

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

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

The description states a clear action and resource: 'Check whether a path looks safe.' This is specific enough to distinguish it from URL-oriented siblings like browser-url-ok. However, the input schema lists eight other unrelated parameters (url, json, zone, query), which muddies what the tool actually checks.

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 other shape/safety checkers. The phrase 'No disk access' hints at one safe-use context, but there is no explicit when/not-to-use instruction or mention of 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 full behavioral burden. 'Via Open-Meteo' implies an external network dependency, but it does not disclose read-only status, failure behavior for unknown places, rate limits, or any side effects. The schema's 'discarded after' notes hint at no-op behavior, but the main description does not add behavioral transparency.

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

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

The description is a single sentence with no wasted language, making it concise and easy to scan. However, it is under-specified for the complexity of the schema, so while it earns a good conciseness score, it is not a fully complete definition.

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

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

With no output schema, no annotations, no required parameters, and 9 optional properties that are not tied to the main description, the definition is not contextually complete. The agent cannot tell which parameter to pass, what errors to expect, or how the 'discarded after' behavior affects the result.

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

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

Schema description coverage is 100%, so the baseline is 3 even without parameter information in the description. The description itself adds no parameter-level guidance, and the candidate parameter 'city' is described only as a 'weather hint' rather than as the place to geocode, which leaves some ambiguity.

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

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

The description clearly signals the tool's output: latitude and longitude for a place via Open-Meteo. It does not use an explicit verb, and it does not mention how the place is identified or how it differs from related siblings like weather-hint or timezone, but the core purpose is recognizably a coordinate lookup.

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 instead of a sibling, and the schema's 9 optional parameters are not tied to any selection condition. There is no 'use this when...' or 'if not... use X' information, so the agent is left to infer when this tool is appropriate.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. 'Parse' implies a read-only transformation, but the description says nothing about return order, error behavior, or that the schema contains many unrelated optional params whose values are discarded during the shape check.

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, front-loaded sentence with no padding. Every word is relevant; there is no filler or redundant restating of the tool name.

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

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

Given the lack of annotations and output schema, plus nine optional parameters with only one clearly relevant to the stated purpose, this description is under-specified. An agent cannot tell which parameters are relevant, what the result looks like, or why the other parameters appear.

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 only limited meaning by indicating that 'url' should be a GitHub URL, which differs from the schema's generic 'HTTPS URL'. It does not help make sense of the other eight schema 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 specific action and resource: 'Parse owner and repo from a GitHub URL.' This clearly distinguishes the tool from siblings like jira-key-shape, figma-url-shape, and domain-shape, which target other URL/expression kinds.

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 guidance about when to choose this tool over alternatives is provided. The sentence implies the use case (having a GitHub URL and needing owner/repo), but it does not state any exclusions or explain the relationship to sibling shape 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 bears the full burden of disclosing behavior. It only says that titles are discarded; it does not mention network access, caching, return format, or failure behavior. The single behavioral hint is meaningful but far from sufficient.

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

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

The description is very short and to the point: the core purpose comes first, and 'Titles discarded' adds a clarifying scoping note. There is no filler.

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

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

The tool has nine optional parameters, no annotations, and no output schema, yet the description does not explain how the parameters relate to the call or what the count actually returns. For a seemingly stateless tool it gets by, but the mismatched parameter list creates real confusion that the description never resolves.

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 describes all nine parameters, so the baseline is 3. The description adds no additional meaning or mapping between those parameters and the count behavior, though none of the parameters are required.

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 ('count') on a specific resource ('current Hacker News front-page stories') and adds a scoping detail ('Titles discarded'). This cleanly distinguishes the tool from siblings like web-fetch or search-query-len.

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 this tool should be used instead of alternatives, nor any indication of prerequisites or context. An agent has to infer when 'count' is the right 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?

No annotations are provided, so the description must disclose behaviors. It says what the tool is about but not what it does with its inputs, whether it is read-only, what the output shape is, or whether parameters like 'ref' and 'city' are actually used. The schema mentions 'discarded' behavior, but the description does not clarify it.

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 phrase with no wasted words, but it is under-specified rather than abcdélicable. It does not front-load an actionable verb or summary.

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

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

With no output schema, no annotations, and a confusing set of nine optional parameters, the description is not enough for an agent to know how to correctly call the tool. It does not explain return format, which parameter is relevant, or whether an empty call is valid.

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 parameters have individual descriptions and the baseline is 3. The tool description adds nothing about how the parameters relate to the 'common IANA timezone names' purpose, but it also does not mislead 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 identifies a specific resource—common IANA timezone names—and that the use context is 'for clock calls.' However, it lacks a verb such as 'list' or 'return,' and the 9-parameter input schema with largely unrelated parameters creates ambiguity about whether the tool returns a list of names or validates one.

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 on when to use this tool versus sibling alternatives like 'timezone' or 'utc-time.' The phrase 'for clock calls' gives a faint context, but there are no cues about when not to use the tool, prerequisites, or how to choose among the optional parameters.

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 carries the full burden. It discloses only that the fetch is 'public' and that only counts are returned; it does not mention error behavior when robots.txt is missing, redirect handling, side effects, or whether the operation is read-only beyond the 'Fetch' phrasing. Some parameter descriptions hint at discard/no-disk-access behavior, but those are schema text, not part of the main description.

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

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

The description is a single front-loaded sentence: verb, resource, and output shape are stated without surplus words. This is structurally efficient, but the conciseness borders on under-specification given the 9-parameter complexity.

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

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

With 9 parameters, no required parameters, no output schema, and no annotations, the description does not convey how the agent should pass the URL/host, what happens when robots.txt is absent, or what shape the 'group counts' result takes. This is a significant completeness gap for a tool that appears to require one of several plausible parameters.

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

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

Schema description coverage is 100%, which gives a baseline of 3. The description adds no parameter-level meaning of its own; it does not illustrate which of the 9 generic parameters (e.g., host, url) maps to the robots.txt location. The schema may document each parameter individually but does not connect them to the tool's specific purpose, so the description does not help the agent choose the correct parameter among the 9.

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 action ('Fetch a public robots.txt') and the specific return value ('group counts only'), which distinguishes it from siblings like web-fetch that would return full content. However, it does not explicitly differentiate itself by name from fetch-status or show how the 9-parameter schema ties to the robots.txt 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 on when to use this tool instead of alternatives such as web-fetch or fetch-status. The description only states what it does; it does not mention any conditions, alternatives, or exclusions, leaving the agent to infer entirely.

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

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

No annotations are present, so the description carries the behavioral burden. 'Key discarded' discloses that the input key is not retained and hints at a side-effect-free read-style check, but it does not explain what the check returns, whether authorization is needed, or the semantics of the 'shape' validation.

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, but the phrase 'Key discarded' is a fragment that loses the subject and adds only minimal value. It is not bloated, but it is close to under-specification rather than genuinely concise clear communication.

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 annotation support, yet the description does not explain which parameter carries the Jira key or what kind of result is produced. A string agent has too much ambiguity to invoke this tool confidently.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no mapping from 'key' to the nine schema properties and does not tell the agent which parameter should contain the Jira key, so it provides no extra parameter-level value.

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

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

The description has a clear verb-resource pair: 'Check a Jira issue key shape.' This makes the tool's basic goal understandable and distinguishes it from siblings like github-repo-shape or domain-shape, though it does not explicitly contrast with them.

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

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

The phrase 'Check a Jira issue key shape' implies the use case: validating something as a Jira key. However, it gives no explicit conditions, exclusions, or alternatives to related shape-checking tools, so the agent has to infer when to pick this over a sibling 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?

No annotations are provided, so the description bears the full responsibility for behavioral disclosure. It does add one useful behavioral trait: 'Body discarded.' But it still leaves unclear which parameter actually supplies the URL, whether a network request is made, how redirects/timeouts/errors behave, and whether other fields are ignored or somehow 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?

Two short sentences with no padding; the first sentence states purpose and the second adds a useful behavioral note. It is appropriately dense, though the omission of the key parameter mapping prevents it from being a 5.

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

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

Given a nine-parameter, all-optional schema and no annotations or output schema, the description is too incomplete: it does not say which parameter to use, what the encoded status looks like, how errors are reported, or whether this is a network request. An agent would have to guess or issue a large number of null parameter calls.

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 with no parameter info in the description. The text adds a small link: 'HTTP status' suggests the 'url' parameter is the operand, but the schema itself says the url parameter is used to 'normalize or cite,' which is confusing and does not fully tell the caller whether the other eight optional parameters matter.

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: 'HTTP status for a public library docs URL. Body discarded.' It is readable and tells the caller what kind of tool this is. However, it does not differentiate this from siblings like fetch-status or browser-url-ok, and it does not directly explain which of the many schema parameters maps to 'a public library docs 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 guidance on when to use this tool versus fetch-status, normalize-url, or web-fetch. The description merely says what it does, without explicit when/when-not conditions, prerequisite steps, or alternatives.

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

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

With no annotations, the description carries the full burden, and it does disclose that values are discarded. However, it does not describe the output format, side effects, or whether state is preserved or modified.

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, front-loaded, and free of filler. It is slightly too terse for the tool's complexity, but as concise prose it is structured well.

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, an agent cannot infer the return value or know which parameter supplies the JSON object. The description is too minimal to fully support correct invocation for a tool with 9 optional 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?

The schema already documents all nine parameters clearly, so the baseline is 3. The description adds no connection between 'JSON object' and the `json` parameter, and it does not explain how the other optional parameters relate to the count.

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 ('count keys') and resource ('a JSON object'), and 'Values discarded' adds useful scope. It is clear but does not differentiate itself from siblings such as validate-json beyond the word 'count.'

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

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

There is no guidance about when to use this tool versus alternatives, and no mention of when it should not be used. The 9 optional parameters also make it unclear how an agent is supposed to select the relevant input.

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 carries the full burden. It does disclose a meaningful behavior (query and fragment are dropped), but it remains silent on broader behaviors: whether network access occurs, any differences across the schema's nine heterogeneous parameters, and error cases. It is honest but thin given the lack of annotation support.

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

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

The description is crisp and front-loaded: one sentence says exactly what is returned, followed by a second sentence disclosing the destructive behavior. Every word earns its place. It is slightly lean given the 9-parameter schema, but as a prose form it is appropriately economical.

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 leaves important gaps: which parameter is the actual input, what happens when the other eight are supplied, whether it returns a string or a structure, and how it handles non-HTTPS or malformed URLs. An agent could reasonably invoke it with 'url', but edge-case and interplay behavior are materially under-specified.

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 sits at 3. The description itself adds little parameter-level meaning; the clause about dropping query/fragment is about URL components, not the 'query' parameter. It never clarifies that only 'url' is meaningful and the other eight parameters appear to be decorative shape checks, leaving the parameter relationships 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 uses a specific verb ('Return') and states concrete output fields (origin, host, path), with the explicit exclusion of query and fragment. It is clear enough to read as a URL-normalization tool, although it does not explicitly differentiate itself from sibling tools such as browser-url-ok, playwright-url-ok, or domain-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?

Usage is implied: use this when you need URL components with query and fragment stripped. However, the description never states when not to use it versus the many URL-related siblings, and gives no scenario-based guidance about choosing this tool over fetch-status, web-fetch, or the url-ok tools.

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

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

No annotations are present, so the description carries the behavioral disclosure burden. It does add one meaningful fact, 'No browser is launched,' and the action is read-style. But it does not state whether a network request is made, whether the result is a boolean, or whether any side effects occur, leaving important gaps.

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

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

The description is two short sentences with no filler. The purpose is stated first and the key behavioral caveat is placed second, so the most important information is front-loaded.

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 output schema, no annotations, and many sibling tools, this is insufficient context. The description does not mention the return value, which parameters are relevant to the URL check, or how the other parameters like 'city,' 'json,' 'path,' and 'zone' relate to the tool's behavior.

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

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

The input schema covers 100% of the parameters with per-field descriptions, so the baseline is 3. The description itself adds no parameter-level meaning and does not explain which of the nine optional parameters should be provided for an effective URL 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 concrete action and resource: 'Check whether a URL can be opened.' The qualifier 'No browser is launched' gives some sibling distinction, especially from browser-url-ok and browser-based tools. However, it does not name alternatives or clarify what 'opened' means (syntax, HTTP reachability, or something else).

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 on when to choose this tool versus the many siblings. 'No browser is launched' hints at one distinction but does not say to use a browser-based tool when browser behaviors are needed or to use another sibling for HTTP status or normalization.

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, and it only offers 'Query discarded' as a transparency statement. While this usefully signals a stateless, side-effect-free call for the query parameter, it says nothing about the other 8 parameters, error behavior, or side effects beyond the length check.

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 essential claim is front-loaded and each word carries weight. The description is appropriately compact for the tool's apparent single-purpose nature.

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?

Even though the tool appears simple, it has 9 parameters and no output schema or annotations. The description doesn't cover what the other 8 parameters do, whether they must be ignored, how errors surface, or what the return format looks like. For a tool wrapped with a disjoint schema, this is 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 per the rubric the baseline is 3. The description adds only a bit beyond the schema (that the query is discarded), which does not meaningfully clarify what to do with the 8 non-query parameters or why they exist alongside a query-length function. It doesn't compensate for the mismatch between the described purpose and the schema's parameter list.

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.' It is clear at the sentence level. It does not explicitly distinguish itself from siblings (e.g., hn-front-count or memory-key-count), and the schema surfaces 9 largely unrelated parameters, so an agent can't tell from the description alone that only the 'query' parameter is involved.

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 exists for when to use this tool versus alternatives. It never mentions siblings, conditions for use, or when not to use it. The only clue is the tool name itself, which the description does not reinforce or expand.

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 behavioral disclosure burden, but 'Short catalog of common HTTP status codes' only discloses that the result is a concise list. It does not state whether any of the nine supplied parameters are used, ignored, discarded, or whether any external/network access occurs. The parameter schema notes 'discarded' behavior, but that is outside the main description.

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

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

The description is short and front-loaded, but it is actually under-specified for a tool with nine unrelated optional parameters. It is concise, but not appropriately sized given the missing guidance about how the parameters should be used.

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

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

Given the tool has nine parameters, no output schema, and no annotations, a one-phrase description is not enough to let an agent confidently call it correctly. It does not explain why parameters such as city, feed, host, and zone are accepted if they are discarded, nor what the returned catalog 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 is 3. The main description adds nothing about how ref, url, city, feed, host, json, path, zone, or query interact with the catalog, but since the schema already documents each parameter clearly, the description does not need to repeat those 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 names a concrete resource—common HTTP status codes—and suggests the tool provides a short catalog of them, so an agent can broadly infer what it does. However, it lacks a specific verb such as 'look up' or 'return', and it does not distinguish this from siblings like fetch-status beyond the word 'catalog'.

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 when-to-use guidance, no exclusion criteria, and no hint about how this tool relates to fetch-status or the other sibling tools. An agent is left to infer when to call it: based only on its name.

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

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

Since no annotations are supplied, the description must carry the behavioral burden. It discloses that the prompt is discarded, but it fails to explicitly say that all parameters are ignored and the output is always the same template. This is only partial transparency, potentially misleading an agent into thinking parameters matter.

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 just two short sentences, with no filler or redundant detail. 'Prompt discarded' is a purposeful, extra piece of info, and the core function is stated upfront. 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 parameters, no output schema, no annotations, and a one-line description. There is no explanation of what the three-step template looks like, why the parameters exist, or how to get value from the call. An agent has no way of knowing the expected output structure or confirming whether the tool is safe to invoke, making the description near-inadequate for this complexity.

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 gives each of the 9 parameters a description, achieving 100% coverage, but the tool description does not clarify how they affect the three-step template. The descriptions like 'discarded' or 'to normalize or cite' actually conflict with the 'Prompt discarded' idea, suggesting parameters may be ignored while still implying possible use. The description fails to reconcile this, leaving parameter semantics unclear.

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

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

The description states a clear action and outcome: 'Return a three-step thinking template'. This is a specific verb and resource, so an agent can grasp the core purpose. It does not explicitly differentiate from siblings, but its name and outcome are distinct enough to avoid immediate confusion.

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

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

There is no guidance about when to use this tool versus alternatives like search-query-len or validate-json. The phrase 'Prompt discarded' hints at a stateless operation, but it does not state a scenario or excluded cases, leaving the agent to guess whether this is the right 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?

With no annotations, the description carries the full behavioral burden. It only says 'Current time', without disclosing that it is read-only, which parameter actually matters, what happens on invalid zones, or whether the other eight accepted parameters are ignored. The parameter descriptions hint at discarding, but the tool description itself does not resolve the mismatch.

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 perfectly compact sentence that front-loads the essential purpose with 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 tool has a confusing 9-parameter schema for what appears to be a single-parameter timezone lookup, with no output schema or annotations. The description does not explain the odd shape, how to select the correct parameter, or what return format to expect, so it is not complete enough 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 baseline is 3. The description identifies 'IANA timezone' as the focus, which maps to the 'zone' parameter, but it adds little beyond the schema and does not clarify why the other eight parameters exist on this timezone tool.

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

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

The description states a specific verb and resource ('current time' in a 'named IANA timezone') and is semantically distinguishable from siblings like utc-time and iana-zones. However, it does not explicitly compare or disambiguate against those siblings, so it misses the full differentiator bar.

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 (e.g., utc-time or iana-zones), and no exclusions or prerequisites. The agent is left to infer that this is for non-UTC IANA time lookups.

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 burden, but it only says the timestamp is current and UTC. It does not say whether the parameters are ignored, what output format to expect, or whether the tool has any side effects or network dependencies.

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 brief sentence with no filler, which is good for conciseness. However, for a tool exposing nine diverse parameters, it is underspecified and does not give the agent enough structure to understand the intended invocation.

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 annotation coverage, and the description does not explain what exact format is returned or how the listed parameters relate to the timestamp result. The presence of 0 required parameters hints that all parameters are optional, but the description never says that directly.

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% descriptor coverage and all parameters are optional, so schema-level descriptions provide basic meaning. The tool description itself adds no parameter explanation and does not clarify why such a varied set of parameters is present on a UTC timestamp 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 explicitly identifies the resource as the current UTC timestamp and is understandable at a glance. It remains a noun phrase rather than an action statement and does not explicitly differentiate itself from sibling tools like `timezone` or `iana-zones`.

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 `timezone`, `iana-zones`, or other siblings. The description does not state prerequisites, typical use cases, or whether the tool should be preferred over 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?

Annotations are absent, so the description carries the full behavioral burden, but it discloses nothing: no read-only or mutation signal, no auth or network behavior, and no statement about side effects or result shape. The phrase 'time-sortable shape' is a property of the ID, not a behavioral trait of the 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 short but not appropriately sized for the tool's complexity; it is a label rather than a functional explanation. No sentence is earned because the sentence provides almost no decision-relevant 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 9-parameter tool with no required fields, no annotations, and no output schema, this description is completely inadequate. It cannot tell an agent what the tool does, what it returns, or why all these parameters exist.

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-level description adds no parameter semantics. The description does not explain how 'time-sortable shape' relates to the nine parameters, but the schema descriptions at least document each individual value.

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

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

The description is a noun phrase that essentially restates the tool name ('UUID v7 time-sortable shape' vs 'uuid-v7-shape'), adding only the property 'time-sortable.' It has no verb or action, so an agent cannot tell whether the tool validates, generates, formats, or otherwise operates on a UUID v7.

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

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

No when-to-use or when-not-to-use guidance is given, and no sibling alternatives are suggested. With nine optional parameters and no indication of which one is relevant, the agent has no help selecting the correct 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?

No annotations are provided, so the description carries the behavioral burden, but it only repeats that the body is discarded, which is already stated in the 'json' parameter description. No side-effect, auth, rate-limit, or return-shape behavior is disclosed beyond the 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?

Two sentences, front-loaded with the operation, no filler. The discard note is the only secondary detail and it earns its place.

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

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

The tool has 9 optional parameters, no output schema, and no annotations. The description does not explain what the return value is, which of the parameters counts as the 'body', or whether the other eight properties are irrelevant. An agent cannot reliably derive the complete call contract.

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 nothing beyond what the schema already says and actually introduces an ambiguous term 'body' that does not correspond to any property name in the JSON 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 verb and target ('check whether a body is valid JSON'), so an agent can infer the main purpose and tell it apart from sibling shape/slug checkers. However, the term 'body' never maps to a concrete parameter in the 9-property schema, leaving a small gap between description and input contract.

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 this when you need to validate JSON text. There is no explicit when-to-use alternative, and it does not mention any sibling like file-path-ok or uuid-v7-shape that could be considered competitors.

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

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

With no annotations provided, the description carries the full disclosure burden. It mentions the external provider but does not state output format, error behavior, whether the other eight parameters are ignored, or any other behavioral consequences of the call.

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

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

The description is extremely short and front-loaded, with no filler or redundancy. It is easy to scan, though its brevity does border on under-specification for such a complex parameter surface.

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

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

For a 9-parameter tool with no annotations and no output schema, the description is incomplete. It does not say which parameter actually causes the tool to call Open-Meteo, why the parameter fields exist, or what shape the returned temperature takes.

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 describes all 9 parameters at 100% coverage, so the baseline is neutral. The description adds almost nothing beyond tying 'city' to the weather purpose; it does not help an agent understand the role of the many unrelated-looking optional fields.

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

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

The description states a concrete verb and resource ('current temperature for a city') plus the provider ('Open-Meteo'), so the intended purpose is clear. It does not explicitly differentiate it from siblings like geo-hint, and the wide unrelated input schema slightly muddies the clarity.

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

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

The description gives no indication of when to prefer this tool over alternatives, nor what context warrants it. It implies a simple weather lookup but provides no exclusions or pointers to sibling tools.

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

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

With no annotations provided, the description carries the behavioral transparency burden. It effectively discloses a key behavioral trait: the HTTP body is discarded and only status/content type are retained. It does not discuss redirect, retry, or timeout behavior, but the central data-handling behavior is clear.

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 is appropriately front-loaded: the main action is stated first, and the important limitation (body discarded) is placed in the second sentence.

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

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

The tool is simple in principle and the description covers the return aspect, but the schema is relatively complex with nine optional parameters and no output schema. A little more guidance on how the many parameters relate to the primary 'public URL' purpose 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?

Schema coverage is 100%, so the schema already documents all nine parameters, which puts this at the baseline. The description adds little beyond naming the public URL scope, and it does not help disambiguate primary target parameters such as url versus feed or host.

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 and resource: get HTTP status and content type for a public URL, and it further notes that the body is discarded. It does not, however, explicitly distinguish itself from closely named siblings like fetch-status or browser-url-ok.

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

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

The description implies usage for checking public URLs and implies that body content is not available. It does not provide explicit when-to-use or when-not-to-use guidance relative to the many sibling tools, leaving the agent to infer the right 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?

The description discloses that the title is discarded after the call, which is a useful behavioral detail. However, with no annotations provided, the description still does not explain network side effects, error behavior, or what it does beyond checking existence.

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, front-loaded, and contains no filler. Both sentences carry relevant information about what the tool does and what happens to the input.

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, and no output schema, the description is too thin to enable reliable invocation. An agent cannot infer which argument is the title, what the return state is, or how this differs contextually from related validators.

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% parameter description coverage, so this dimension starts at the baseline. The description itself adds no extra parameter meaning and, more importantly, does not identify which of the nine optional fields is the title to check.

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

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

The description clearly states the action and resource: checking whether a Wikipedia title exists. It does not distinguish this from sibling tools, but the core purpose is not vague or tautological.

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

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

No guidance is given for when to use this tool versus alternatives like web-fetch or fetch-status, or when it may be preferable to the sibling shape-checking tools. The intended use is only implied 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.