ISO country MS

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

With no annotations, the description carries the transparency burden. It does disclose that task text is discarded and that the tool returns documentation-style content, and 'pay-per-call' signals possible cost implications. However, it does not state whether external network calls are made, whether there are side effects, or what happens on failure.

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

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

The description is a compact two-sentence statement that front-loads the core purpose and outputs. It contains no filler or redundant restatement of the tool name.

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

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

The description lists outputs and notes that task text is discarded, which is useful for a tool with zero required parameters. However, it leaves the purpose and use of the nine optional parameters ambiguous, and with no output schema or annotations, an agent gets only a partial picture of how to correctly interact with the tool.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description itself adds no parameter-level detail. Each of the nine parameters has an explanatory schema description, mostly noting that the value is discarded after validation.

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 ('Find a public pay-per-call tool gateway (Monid)') and lists concrete outputs: CLI setup, how-it-works, skill file, and remote MCP hops. This clearly differentiates it from the many sibling validation and fetch tools.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives, nor does it name any sibling for comparison. 'Task text discarded' hints at a limitation but does not explain the intended invocation 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?

With no annotations, the description carries the full behavioral burden, but only states a single non-behavior ('No browser is launched'). It does not disclose whether the URL is fetched over the network, what result is returned, whether inputs are discarded, or any side effects beyond browser launch.

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 key non-browser behavior is front-loaded. It is concise, though arguably too sparse for the tool's complexity.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, this one-line description is insufficient. It does not specify the intended parameter usage, the meaning of a positive/negative result, or any operational constraints beyond not launching a browser.

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. It introduces the URL concept but does not explain how the nine optional parameters relate to 'a URL' or which one should be supplied.

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 ('Check') and resource ('whether a URL can be opened'), and adds 'No browser is launched' to separate it from browser-launching siblings like playwright-url-ok. However, 'can be opened' is left ambiguous – it could mean syntactic validity, 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?

No guidance is given for when to choose this tool over alternatives such as playwright-url-ok, web-fetch, or normalize-url. The only implied distinction is that no browser is launched, but no explicit condition or alternative is named.

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

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

With no annotations, the description carries the transparency burden. It does disclose one meaningful behavior: the expression is discarded, implying no persistence. But it does not disclose the return value, error behavior, or whether the other schema parameters participate, so the disclosure is only partial.

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

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

The description is short, front-loaded, and free of filler, but it is under-sized for a 9-parameter tool. The cryptic 'Expression discarded' phrase and the lack of any connection to the schema make it less appropriately sized than truly concise.

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

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

The tool has 9 optional parameters, no annotations, and no output schema, so the description must carry the load. It provides a clear purpose and a discard note, but leaves the main input unmapped and says nothing about the result, making correct invocation impossible from the definition as given.

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

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

Although all nine schema parameters have descriptions, none of them represents an arithmetic expression. The description's key input—'expression'—has no mapped schema property, so an agent cannot know where to put '2+2'. This is actively misleading rather than additive.

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') and a specific resource ('a+b style arithmetic'), making the tool's core purpose clear. It also distinguishes this tool from the many sibling shape-checkers and normalizers, since no sibling is described as an arithmetic evaluator.

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 opening phrase implies the tool should be used when an agent needs to evaluate simple arithmetic, so there is implied usage guidance. However, it never states exclusions, prerequisites, or when to prefer a sibling tool, leaving the routing decision mostly 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 full burden of behavioral disclosure. It usefully states that page content is not stored, but it omits potential network side effects, handling of the many non-URL parameters, authentication needs, and output format.

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

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

The description is two sentences, front-loads the return fields, and contains no filler. The non-storage note adds meaningful information without bloating the text.

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

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

Despite the simple core statement, the tool has nine parameters, no output schema, and no annotations. The description does not explain the role of the discarded parameters, whether any inputs are required, or how the result is returned, making it incomplete 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?

Schema description coverage is 100%, so the input schema already documents all nine parameters. The description adds little beyond identifying url as the core input, warranting the rubric baseline 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 names a concrete operation: returning host, scheme, and HTTP status for a URL. It is clear and uses a specific verb and resource, though it does not explicitly differentiate itself from siblings like fetch-status or normalize-url.

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

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

There is no guidance on when to use this tool instead of the many sibling URL/status/check tools, and no alternatives or exclusions are mentioned. The non-storage note hints at a privacy-relevant use case, but this is implicit rather than actionable.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal that identifiers are not retained, which is useful, but it does not clarify whether the tool mutates anything, what happens to the inputs, how results are returned, or what 'classified' concretely entails.

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

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

The description is two short sentences with no filler, and the core purpose is front-loaded. It could be more informative, but as written it is economical and every sentence contributes something.

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

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

For a tool with nine optional parameters, no output schema, and no annotations, the description is not complete enough for an agent to know which parameter(s) to provide, what the returned classification looks like, or how this tool fits among the many sibling tools. The individual schema descriptions help but do not resolve the overall calling convention.

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

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

Schema description coverage is 100%, and each parameter has a clear one-line explanation including disposition (e.g., 'discarded after the check'). The tool description itself adds no parameter meaning, but the schema already carries that weight, so the baseline score of 3 is appropriate.

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

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

The description says the tool 'shows how this request is classified', which names an action and an output but is vague about what classification means or what resources/categories are involved. It does not meaningfully distinguish the tool from siblings like agent-tool-index or status-catalog, so an agent must infer its role.

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

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

There is no guidance on when to use this tool versus alternatives, no stated conditions, and no mention of how the many optional fields should be supplied. The 'No identifiers are retained' note is a privacy guarantee, not a usage guideline.

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 single sentence does say the operation excludes WHOIS/ownership data, which is useful, but it does not disclose return shape, error behavior, side effects, or whether the split is pure and local. For a tool with zero annotations, this is a significant gap.

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

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

The description is a single compact sentence with no filler; the core operation and the key exclusion are both front-loaded. Every phrase 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?

With no output schema, no annotations, and nine optional parameters, the description leaves important operational details unclear: which parameter is the actual hostname input, what the tool returns, and whether providing multiple parameters is meaningful. The definition is minimally understandable but not complete enough for an agent to invoke 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 even though the tool description adds no parameter mapping. Each parameter is individually described, such as 'host: Public hostname', but the description does not explain why many unrelated fields appear or how they interact with the hostname split.

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 ('split') and resource ('hostname into labels'), and the negative 'without WHOIS or ownership data' sets clear boundaries. It is immediately distinguishable from sibling shape tools like github-repo-shape, figma-url-shape, or jira-key-shape, which target different entity types.

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 the tool is for hostname structuring when ownership/WHOIS data is not needed, but it never explicitly states when to prefer this over normalize-url, github-repo-shape, or other siblings. No when-not-to-use conditions or alternative tool names 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 provided, the description carries the full behavioral burden. It clearly discloses the HTTP method, the public-URL scope, and the status-only output, which gives a solid safety and behavior profile for a read-only probe.

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

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

The description is a single front-loaded sentence with no filler. Every word earns its place by stating the method, target, and output.

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

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

For a tool with 9 optional parameters, no output schema, and no annotations, a one-sentence description is insufficient. It does not clarify which field maps to the URL, that all other fields are ignored, or what 'status' looks like in the response, leaving an agent with real invocation 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?

Although schema coverage is 100%, the schema descriptions are mismatched with the tool's stated purpose: the 'url' parameter is described as 'HTTPS URL to normalize or cite', not as the target of a HEAD request. The description never tells the agent which parameter to populate or that the other nine optional fields are irrelevant, so parameter selection is unnecessarily 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 gives a specific verb ('HEAD'), a resource ('a public URL'), and the output ('status only'). It clearly distinguishes itself from content-fetching siblings like web-fetch by limiting the result to status.

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

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

The phrase 'status only' implies the tool should be used when only an HTTP status is needed, not full content. However, it does not explicitly name alternatives or state when not to use it, leaving selection among siblings like browser-url-ok and web-fetch 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. 'Path discarded' is the only behavioral trait disclosed; the description does not mention whether the tool validates, fetches, returns a normalized URL, or reports errors. This is insufficient for a tool with no annotation safety context.

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 two short sentences and no filler. 'Parse a Figma file URL' is front-loaded and directly names the core action. The brevity is partly a result of under-specification, but as far as conciseness itself, it is efficient.

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

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

Given nine optional parameters, no output schema, and no annotations, the description is far too thin to be complete. It does not explain the return value, what 'shape' means, which single input is relevant, or why the other parameters exist. The agent is left guessing about invocation semantics.

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 description does not map to any specific parameter. The schema's 'url' property is described generically as 'HTTPS URL to normalize or cite,' not as a Figma URL, and the 'path' property refers to a file path, making 'Path discarded' ambiguous. With nine optional parameters and no required fields, the agent cannot confidently determine which parameter to pass.

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: 'Parse a Figma file URL.' This clearly identifies the tool's domain and distinguishes it from sibling URL tools like normalize-url, browser-url-ok, and web-fetch, which do not target Figma URLs specifically. The added 'Path discarded' hint gives a concrete 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?

The description provides no guidance on when to use this tool versus alternatives such as normalize-url or browser-url-ok. It never explains conditions, exclusions, or prerequisites, so an agent cannot determine whether to pick this tool over a sibling.

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

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

With no annotations, the description must carry behavioral disclosure, and it provides only 'No disk access.' It does not explain what 'looks safe' means, whether the call returns a boolean or throws, whether it normalizes paths, or whether the other schema properties are ignored, so the behavior remains largely opaque.

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

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

The description is two short sentences with no filler, and the main action plus the key side-effect qualifier are front-loaded. It is appropriately compact for a simple check, though its brevity leaves behavioral gaps that are penalized in other dimensions.

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

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

There is no output schema and no annotations, so the definition should cover what the check returns and what 'safe' means, but it does not. The broad optional input schema and absence of a required parameter also make it incomplete: an agent cannot tell whether to pass only `path`, multiple fields, or none.

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% and each property has a descriptive comment (e.g., 'File path to check; no disk access'), so the description does not need to restate parameter meanings. The main gap is that the description does not clarify that `path` is the relevant parameter among many optional fields, but the schema itself is informative enough to keep this at baseline.

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

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

The description names a concrete action ('Check whether a path looks safe') and a clear resource, with 'No disk access' adding useful scope. However, the input schema exposes several unrelated optional properties (ref, url, city, feed, host, json, query), so the description does not make clear that `path` is the effective input, creating ambiguity about the actual 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 file-path-ok versus alternatives, nor any exclusion such as 'use a filesystem tool if you need existence checks.' The only contextual signal is 'No disk access,' which weakly implies a non-filesystem validation but does not state when this check 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 burden of behavioral disclosure. It mentions 'via Open-Meteo,' implying an external lookup, but does not explain that many inputs appear to be discarded after validation, nor does it describe side effects, response format, error behavior, or privacy implications of sending city/URL/feed/path data to an external service.

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

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

The description is very short and front-loaded, but for a tool with nine parameters, no output schema, and no annotations, this level of brevity is under-specification rather than effective conciseness. It lacks any structured or contextual detail that would justify its minimal length.

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 for a tool with nine loosely related parameters and no output schema. It does not explain how the parameters map to 'a place,' what the response looks like, or what 'hint' means in the tool name. Including the broader context of the sibling tools would also help, since many siblings are shape-check utilities and geo-hint's role is unclear.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning, but the schema already documents each parameter, including notes about values being discarded. The description does not help the agent decide which of the nine optional parameters to supply for a geographic lookup.

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 returns latitude and longitude for a place via Open-Meteo, which names a clear result and service. However, it does not specify how a place is identified, and the input schema contains many unrelated-looking parameters (ref, feed, json, path), making the tool's actual scope unclear. It also does not differentiate it from siblings like weather-hint or timezone.

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

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

There is no guidance on when to use this tool versus alternatives, no mention of when it should not be used, and no indication of which parameter is appropriate for a given use case. The description only implies a single purpose without contextual direction.

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 says 'Parse', which hints at a local, non-mutating operation, but it does not state what happens for malformed URLs, whether the URL is fetched or validated, or what errors occur. The 'discarded after the shape check' notes in the schema are not reflected in the 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 with no filler. It presents the action, object, and result before any possible elaboration, which is optimal for the limited content it covers.

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, one sentence is not enough. The description does not identify which parameter to populate, what is ignored, what the return shape is, or how invalid input is handled. The schema's generic parameter descriptions do not compensate.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds the critical meaning that the subject is a GitHub repo URL and that owner/repo are extracted, but it never names the 'url' parameter or explains why the other eight optional parameters exist, leaving a large mapping gap.

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 specific verb ('Parse'), a specific resource ('GitHub URL'), and the expected result ('owner and repo'), which makes the core purpose unambiguous. The GitHub-specific wording separates it from sibling shape tools like domain-shape, jira-key-shape, and figma-url-shape.

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

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

The wording implies the tool is for extracting repository components from a GitHub URL, but it gives no explicit when-to-use guidance and names no alternatives. With 27 sibling tools, an agent must infer that this tool is preferred over normalize-url or browser-url-ok, rather than being told.

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 must carry the behavioral burden. It does disclose two useful traits: the count is of the current front page and titles are discarded. It does not state whether the tool fetches HN itself, whether it uses a provided feed URL, or what the return value looks like, so the disclosure is only partial.

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

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

Two short sentences, with the main purpose front-loaded and no redundant phrasing. Every word contributes: 'current' sets scope, 'Count...stories' states the action, and 'Titles discarded' clarifies the output boundary.

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

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

With no annotations, no output schema, and a nine-parameter optional schema, the description is too thin to fully support invocation. An agent still cannot tell whether to pass no arguments, a feed URL, or some other parameter, nor what the counted result 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?

All nine parameters have schema descriptions, so the baseline of 3 applies. The tool description adds no parameter guidance; only the 'feed' parameter's 'titles discarded' wording aligns with the description, while many other parameters (city, zone, json) look unrelated to counting HN stories.

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 ('Count'), a specific resource ('current Hacker News front-page stories'), and a clear output boundary ('Titles discarded'). This is enough for an agent to distinguish it from siblings like web-fetch or fetch-status, which do different things.

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

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

The intended use is implied: call this when the agent needs the number of stories currently on the Hacker News front page. However, there is no explicit when-to-use versus alternatives, no exclusions, and no mention of whether a parameter is needed to trigger the count.

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. The description does not state an action, return value, side effects, or whether the tool is read-only. It is a noun phrase with no behavioral disclosure.

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

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

The description is a short, single-phrase definition with no wasted words. It is concise, though arguably too sparse to be fully useful. The brevity is acceptable as a structural quality but not a substitute for content.

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

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

There is no output schema and no annotations, and the tool has nine optional parameters with no obvious connection to the stated purpose. The description does not explain what the agent should expect as a result or how to invoke the tool correctly, making the definition 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 the baseline is 3. However, the description itself adds no parameter-specific meaning, and the schema's many optional parameters appear unrelated to timezone names. The description does not clarify which parameters matter for this 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 identifies a resource (IANA timezone names) and a context (clock calls), but it has no verb and does not state whether the tool returns, lists, or validates these names. It also does not differentiate it from sibling tools like timezone or utc-time, leaving the exact role 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 phrase 'for clock calls' implies the tool is meant to supply timezone names for clock-related operations, but it gives no explicit guidance on when to use this tool versus alternatives such as timezone or utc-time. There are no exclusions or decision criteria.

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 states that only group counts are returned, but does not explain network behavior, failure modes, redirects, rate limits, or what 'group counts' actually means. For a network-fetching tool, this is a significant transparency gap.

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

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

The description is a single front-loaded sentence with no filler. It is concise and easy to scan, though it sacrifices critical parameter linkage.

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, and no output schema, the description is too thin. It leaves the agent guessing about input selection, output shape, and edge cases, so it is not complete enough 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?

Although every parameter has a schema description, the tool description never connects robots.txt to any specific parameter. With 9 optional parameters including unrelated-looking ones like city, feed, and json, an agent cannot reliably determine which parameter supplies the robots.txt URL 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 names a specific action ('fetch a public robots.txt') and a specific output ('return group counts only'), so the purpose is clear. It does not explicitly distinguish itself from siblings like web-fetch or fetch-status, so it stops short of a 5.

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

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

There is no guidance about when to use inspect-robots versus alternatives such as web-fetch, browser-url-ok, or normalize-url. The word 'only' hints at the tool's narrow scope, but no when-to-use or when-not-to-use context is 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?

The description adds one behavioral note ('Key discarded'), implying the input is not retained, but there are no annotations to fall back on. It does not disclose whether the tool returns a boolean, throws on invalid shapes, or what 'shape' validation entails.

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. However, the second clause 'Key discarded.' is cryptic and would benefit from being folded into a clearer, complete 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?

With seven parameters, no annotations, and no output schema, this description is far too sparse. It fails to identify the required parameter, the expected return value, error behavior, or how this tool relates to sibling shape-checking 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 schema provides descriptions for seven parameters, but none is linked to the Jira key concept in the tool description. The phrase 'Key discarded' does not map to any schema property, so the agent cannot determine which field to populate.

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

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

The description names a specific operation ('Check a Jira issue key shape') and helps distinguish from sibling shape-checkers like domain-shape or github-repo-shape. However, the schema contains no 'key' parameter, and 'Key discarded.' is ambiguous about which input is the key, weakening 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?

No guidance is given about when to use this tool over alternatives, nor any exclusions or prerequisites. The intended use can be inferred only from the tool name and first sentence, with no explicit direction or 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?

No annotations are present, so the description must carry behavioral context. It clearly discloses that only the HTTP status is returned and the body is discarded, but it does not mention error behavior, redirects, or whether the request is read-only/safe.

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 redundancy; 'HTTP status' is front-loaded and 'body discarded' earns its place as a key behavioral qualifier.

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

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

With 9 optional, unrelated parameters, no output schema, and no annotations, the description is too sparse to tell an agent what to pass or what to expect beyond a status code. It does not explain how to request the library-docs check or how to interpret the result.

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

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

Schema coverage is 100%, so the schema carries the parameter meaning and the baseline is 3. The description adds no per-parameter guidance, and the many 'discarded' fields leave ambiguity about which field corresponds to the described library-docs URL.

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

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

The description gives a specific verb and observable outcome: returns the HTTP status for a public library docs URL and discards the body. That distinguishes it from content-returning fetch tools, though it does not name a sibling and 'public library docs' is somewhat ambiguous.

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

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

It implies usage when only an HTTP status is needed ('Body discarded'), so an agent can infer not to use a body-returning fetcher. But it never names alternatives like fetch-status or web-fetch and gives no explicit when-not-to-use guidance.

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

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

With no annotations, the description carries the full behavioral burden, but it only discloses that values are discarded. It does not state whether nested keys are counted, whether invalid JSON is an error, what the return value looks like, or which of the nine parameters is the input; the schema's 'json' parameter says 'validate' rather than 'count', which adds ambiguity.

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

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

The definition is only two sentences, front-loaded with the core operation and no filler. The second sentence adds a useful behavioral qualifier, though the overall terseness contributes to the ambiguity penalized elsewhere.

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

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

For a tool with nine parameters, no annotations, and no output schema, this is incomplete: it does not identify which parameter holds the JSON object, what the count means, or what the tool returns. An agent cannot reliably construct a correct invocation from this description alone.

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

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

Although the schema claims 100% parameter coverage, the parameter descriptions are largely unrelated to counting keys (e.g., git ref, URL, city, feed, host, path) and the 'json' parameter is described as text to validate, not as the object whose keys are counted. The tool description does not map 'JSON object' to any parameter, so the high schema coverage does not help an agent populate the call.

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

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

The description opens with a specific verb ('Count') and a concrete resource ('keys in a JSON object'), clearly distinguishing this from validation and shape-checking siblings. The additional phrase 'Values discarded' removes ambiguity about whether values are preserved.

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 instead of validate-json or the many shape-check siblings, nor any exclusions or context. The agent must infer usage from the name and one-line description.

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

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

With no annotations, the description carries the burden of behavioral disclosure, and it does add a useful transformation detail: query and fragment are dropped. However, it does not explain normalization behavior (e.g., default ports, punycode, trailing slashes) or potential failure modes, so it is only partially 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?

Two short sentences, front-loaded with the main output and the key transformation. Every word earns its place; there is no redundancy or 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 9 parameters, 0 required parameters, no annotations, and no output schema, yet the description only covers the happy-path output for a URL. It is not complete enough for an agent to confidently call this tool, especially given the confusing parameter list and the presence of many URL-related sibling tools.

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

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

Schema description coverage is 100%, so the baseline is 3 even without additional parameter explanation in the description. The description does clarify that URL query and fragment are discarded, but the 9-parameter schema remains confusing and the description does not resolve why many parameters appear unrelated to URL normalization.

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 verb ('Return') and a precise resource/output set ('origin, host, and path') for a URL, making the tool's core purpose unambiguous. It does not explicitly distinguish itself from sibling URL-related tools, so it stops short of a 5.

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

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

No guidance is given about when to prefer normalize-url over siblings like browser-url-ok, figma-url-shape, domain-shape, or web-fetch. The description is purely functional and leaves all selection logic to inference.

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

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

With no annotations, the description must carry the behavioral burden. 'No browser is launched' is a meaningful behavioral disclosure, but it does not explain how the check is performed, whether it is read-only, what response is returned, or what happens for unreachable URLs.

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

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

Two short sentences, front-loaded with the purpose and a key caveat. No filler, 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 no annotations, no output schema, and 9 optional parameters, the description is too sparse. It omits the meaning of 'can be opened', the return value, which parameters are relevant, and how this differs from the many sibling tools.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning beyond the schema and does not clarify how the 9 optional parameters relate to a URL-open 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 clear action and object: 'Check whether a URL can be opened.' The added caveat 'No browser is launched' helps separate it from browser-based siblings such as browser-url-ok, though it does not explicitly name the alternatives.

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

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

There is no guidance on when to choose this tool instead of siblings such as browser-url-ok, fetch-status, or web-fetch. The no-browser caveat hints at a lightweight check, but no explicit selection criteria 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?

No annotations are present, so the description carries the transparency burden. It does disclose that the query is discarded, which is useful. But it does not state the return format, what happens if `query` is omitted, or how the other optional parameters are treated, leaving important behavioral gaps.

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

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

The description is two short sentences with no filler. The purpose is front-loaded, and the side-effect statement 'Query discarded' earns its place. This is an appropriately concise structure for a simple counting tool.

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

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

Despite 100% schema description coverage, the tool has nine optional parameters, no output schema, and no annotations. The description is not complete enough for an agent to confidently invoke it: it fails to specify that `query` is the only relevant parameter, what the return value looks like, or what happens when multiple parameters are 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 description coverage is 100%, so the baseline is 3. The tool description adds no parameter-specific semantics, though the `query` parameter's schema description ('Search text; discarded after the length check') aligns with the tool's stated purpose. The unrelated parameters remain confusing because the description does not clarify their role.

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 verb and resource: count characters in a search query. The name 'search-query-len' reinforces this. It is distinguishable from sibling counting tools like memory-key-count or hn-front-count, but it does not explicitly tie the purpose to the `query` parameter or address the many unrelated schema fields, so it stops short of a 5.

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

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

The description implies the tool should be used when an agent needs the character count of a search query. However, it provides no explicit guidance about when not to use it, no alternative tool mentions, and no clarification that the other eight schema parameters are irrelevant or ignored.

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

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

With no annotations, the description must carry the behavioral burden. It merely calls the tool a 'catalog' without stating whether it makes external calls, modifies state, or what happens with the provided parameters. The schema hints at 'discarded' values, but the tool description provides no such 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 one clean, front-loaded sentence with no filler. It is concise and readable, though arguably too terse for the tool's actual 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?

The tool has seven diverse parameters and no annotations or output schema, yet the description is a single noun phrase. It does not reconcile the purpose of a 'catalog' with the inputs like 'Git ref' or 'JSON text', leaving an agent unable to anticipate invocation behavior or return values.

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 parameters with specific details (e.g., 'discarded after the shape check'), so schema coverage is high. The tool description itself adds no parameter meaning, leaving the baseline of 3 appropriate.

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

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

The description identifies the resource ('common HTTP status codes') and labels it as a 'catalog', but it lacks a verb and does not specify what the tool actually does (e.g., returns a list, looks up a code, validates a status). It also does not distinguish itself from siblings like fetch-status, which also deals with HTTP statuses.

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

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

The description gives no guidance on when to use this tool versus alternatives such as fetch-status or domain-shape. There is no context about intended use cases, 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?

With no annotations, the description carries the disclosure burden. It does reveal that the prompt is discarded, which is a genuine behavioral trait. However, it does not explain whether the seven input parameters are also ignored, what side effects (if any) exist, or why the tool accepts so many unrelated fields. The disclosure is honest but incomplete.

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

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

The description is very short and front-loaded with the primary action. 'Prompt discarded' is a useful second sentence with no wasted words. It could be considered slightly cryptic about the overall purpose, but as conciseness it is strong.

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 seven heterogeneous parameters, no output schema, and no annotations, the description is too sparse. An agent cannot tell why such different inputs are accepted, whether they affect the returned template, or how this tool relates to sibling tools. The short description leaves important 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?

The input schema provides detailed descriptions for every parameter, including whether each value is discarded. The description itself adds no parameter-level meaning, and since schema coverage is effectively 100%, a baseline of 3 is appropriate.

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

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

The description states a specific verb ('Return') and a clear object ('a three-step thinking template'). It is not tautological and the phrase 'Prompt discarded' adds clarity about behavior, but it does not differentiate from the many sibling tools that also handle inputs like URLs, JSON, or weather hints.

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 any sibling tool, no explicit context, and no exclusions. The description only says what it does, not when an agent should choose it over alternatives like normalize-url or validate-json.

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, but it only states what the tool returns. It fails to disclose that non-zone parameters are accepted only to be checked/discarded, how invalid timezones are handled, or what the response contains beyond 'current time'.

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 free of filler and front-loaded, but for a tool with nine optional parameters and no sibling differentiation, it is under-specified rather than appropriately concise. Brevity comes at the cost of necessary 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?

Given no annotations, no output schema, and a complex 9-parameter input, the description is incomplete. It does not mention the return format, invalid-zone behavior, that only 'zone' is used, or how this relates to sibling timezone 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?

Input schema coverage is 100%, so the schema already documents every parameter. The description only restates that a named IANA timezone is expected, which duplicates the 'zone' parameter description; it adds no semantic value beyond the baseline for high schema coverage.

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

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

The description clearly states the operation: returning the current time for an IANA timezone. It does not explicitly distinguish from siblings like utc-time or iana-zones, and the oversized 9-parameter schema introduces unrelated fields, but the core purpose is unambiguous.

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

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

No guidance is given about when to prefer this tool over utc-time or iana-zones, nor does it state that only the 'zone' parameter is relevant while the other eight fields are ignored. The agent must infer usage from the parameter names and schema descriptions.

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 bears full responsibility for disclosing behavior. It only says 'Current UTC timestamp.' and does not mention that all input parameters are discarded, that the operation is read-only, or any limitations/edge cases. The lack of explanation for the seven seemingly unrelated parameters in the schema is a significant transparency gap.

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

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

The description is a single short sentence, 'Current UTC timestamp.', which is extremely concise and front-loaded with the main purpose. However, it may be too terse, omitting necessary context about the parameters, but for a simple tool the brevity alone is good structure.

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 tool's apparent simplicity, the schema includes seven parameters that appear unrelated to returning a UTC timestamp. The description does not explain why these parameters exist or that they are all ignored, leaving an agent confused about how to invoke the tool. There is also no output schema to clarify the return value, making the definition 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?

All seven parameters have explicit descriptions in the input schema (e.g., 'discarded after the shape check', 'no disk access'), so schema coverage is effectively 100%. The tool description adds no parameter information, but per the baseline rule for high schema coverage, a score of 3 is appropriate.

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

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

The description 'Current UTC timestamp.' states the tool's core function, but it essentially restates the name 'utc-time' without adding specifics such as the format (Unix seconds vs ISO string) or scope. It is clear enough at a high level but does not actively distinguish 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?

The description gives no guidance on when to use this tool versus alternatives. There is no mention of use cases, prerequisites, or exclusions, and no reference to sibling tools such as 'timezone' or 'iana-zones'. An agent is left to infer the appropriate context entirely from the name.

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

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

With no annotations present, the description carries the behavioral disclosure burden. 'The body is discarded' clearly communicates that input is not retained, which is useful side-effect information for an agent. It does not cover other potential behaviors like return values or network effects, but it provides a meaningful behavioral trait.

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

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

The description is two short sentences with the core purpose front-loaded and no wasted words. The discard-side-effect statement is separate and purposeful.

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, the description is too sparse to be fully complete. It does not explain the return value or outcome of validation, nor does it map 'body' to the actual 'json' parameter or clarify the role of the other schema fields.

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 high description coverage, with each parameter documented including the relevant 'json' parameter. The description itself adds no parameter semantics and even introduces an ambiguous 'body' term, but the schema compensates sufficiently to reach the baseline.

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

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

States a specific action ('Check') and target ('whether a body is valid JSON'), which is clear and aligns with the tool name. It does not explicitly distinguish itself from sibling validation/shape tools, but the JSON-specific focus makes its purpose reasonably clear.

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, and no exclusions or prerequisites are mentioned. The purpose implies usage for JSON validation, but the description does not help an agent choose it over sibling shape-check tools.

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

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

No annotations are provided, so the description carries the full burden of explaining behavior. It does not mention that this is a live external lookup, that other input fields are discarded, what units the temperature is returned in, or any rate/error behavior. 'Via Open-Meteo' hints at an external service, but significant behavioral detail 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, repetition, or extraneous detail. It efficiently states the operation, the target input, and the data source.

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 too sparse. It does not tell the agent which parameter to populate, that the other parameters are effectively ignored, or what the return format looks like. This leaves substantial room for mis-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 input schema has 100% description coverage, so all parameters are already documented structurally. The description adds no new parameter meaning; it only repeats that a city is the relevant location input, which the city field description already states.

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

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

The description clearly states the tool's function: get the current temperature for a city, and it names the data source (Open-Meteo). It does not explicitly distinguish itself from siblings like geo-hint or web-fetch, but the weather-specific language makes the core purpose obvious.

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 the tool should be used when a current city temperature is needed. It provides clear functional context, but it gives no explicit when-not-to-use guidance or alternative tool routing, so it does not reach a 5.

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, and 'Body discarded' is a valuable, non-obvious behavioral disclosure. It also clarifies that the tool works on public URLs, implying no authentication. It does not detail redirect handling or error behavior, but the key limitation is surfaced.

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, compact sentence with the primary output front-loaded and the critical limitation stated immediately. Every word earns its place, and no unnecessary detail is included.

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 and no output schema, yet the description only addresses 'a public URL.' It does not explain which parameter to populate, whether the tool accepts multiple input types, or what the return format looks like. The mismatch between the narrow URL description and broad schema makes the description incomplete for an agent.

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

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

Schema description coverage is 100%, so the schema already documents every parameter. The description adds general context about public URL usage and body handling but does not add meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly communicates the core function: retrieve the HTTP status and content type for a public URL, with the body discarded. It is specific enough to distinguish web-fetch from generic URL tools, though it does not explicitly name or contrast sibling tools.

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

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

The description provides only a minimal usage context: public URL and body discarded. It offers no guidance on when to choose this tool over siblings such as fetch-status, browser-url-ok, or playwright-url-ok, and it does not state exclusions or conditions clearly.

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, but it only says 'Title discarded after the call,' suggesting no persistence without explaining what 'title' refers to. It does not disclose the expected result, error behavior, auth, or rate limits. The phrase adds a behavioral hint but is too vague and unconnected to 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 two sentences and front-loads the core purpose. The second sentence is concise, though its 'discarded' phrasing is ambiguous. Overall, it is appropriately sized for a simple check tool.

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

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

For a tool with no output schema and no annotations, the description must explain result behavior and input mapping, but it does neither. It fails to identify which parameter carries the Wikipedia title or what the tool returns (e.g., boolean). The severe disconnect between the stated purpose and the provided schema makes the definition 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?

Although the input schema has 100% parameter descriptions, the tool description never ties 'Wikipedia title' to a specific parameter, and none of the listed properties (ref, url, city, feed, host, json, path) is obviously a title. The schema documents each field individually, but the semantic link needed to invoke this tool is missing.

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

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

The description uses a specific verb and resource: 'Check whether a Wikipedia title exists.' This distinguishes it from sibling URL/file/JSON validation tools. However, it never maps 'title' to any of the 7 input schema parameters, so the purpose is clear only at a high level.

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

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

There is no guidance about when to use this tool versus siblings such as normalize-url, validate-json, or fetch-status. The second sentence about discarding the title is a behavior note, not a usage condition. An agent must infer when the tool applies.

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