ISO country MV

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

With no annotations, the description must carry the full burden of behavioral disclosure. It does state that task text is discarded and that setup materials are returned, but it does not disclose whether external calls are made, whether the operation is read-only, or whether the many input parameters are simply shape-checked and ignored.

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

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

The description is concise and front-loaded with the main purpose, consisting of three short sentences without filler. The 'Task text discarded' warning is useful, though placing it earlier would improve prominence.

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 incomplete. It does not explain how to choose among the parameters, what a valid invocation looks like, what Monid is, or what the returned CLI setup and skill file actually contain, leaving too much to inference.

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 structured field descriptions fully document all nine parameters. The tool description adds no parameter-level meaning beyond the generic 'task text discarded' warning, 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 identifies a specific action ('Find') and a resource ('public pay-per-call tool gateway (Monid)'), and it lists what the tool returns. However, the terms 'Monid' and 'MCP hops' are unexplained jargon, and the tool's relationship to its many sibling utilities is not clear, leaving the overall purpose somewhat vague.

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 explicit when-to-use or when-not-to-use guidance, and it does not reference any alternative sibling tool. 'Task text discarded' is a boundary hint but does not tell an agent when to choose this tool over web-fetch, normalize-url, or other siblings.

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

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

The description discloses one behavioral trait: no browser is launched. But with no annotations, it leaves major behavior unexplained: whether a network request is made, whether the check is read-only, what 'can be opened' means, and what the return value represents. The schema hints at 'discarded after shape check,' but the description itself does not provide this 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 one short sentence that front-loads the core action and the key caveat. There is no fluff, repetition, or unnecessary detail.

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

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

For a tool with nine optional parameters, no output schema, and no annotations, the description is too sparse. The agent cannot tell whether 'ok' means valid URL shape, successful HTTP fetch, or browser-openable, and the description doesn't explain the apparently disposable input 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%, so the baseline is 3; the description adds no parameter-specific meaning. All nine parameters are already described in the schema, including discard behavior, so the description does not need to compensate.

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 ('Check whether a URL can be opened') and a resource ('URL'), and adds a meaningful exclusion ('No browser is launched'). However, it doesn't differentiate from similar non-browser URL tools like web-fetch or fetch-status, since those also check URL reachability without launching a browser.

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 alternatives. 'No browser is launched' gives a hint that it may be cheaper than playwright-url-ok, but it doesn't state when to prefer this over web-fetch, fetch-status, or normalize-url, nor does it mention that the schema suggests a shape-based check.

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 disclose that the expression is 'discarded,' which is a useful behavioral note, but it fails to explain whether an evaluation result is returned, what side effects exist, or how the expression is supplied. This leaves a critical gap for a tool whose core function is evaluation.

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

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

The description is very short and front-loaded: it states the core action in the first sentence and adds a behavioral note in the second. There is no fluff, but the brevity crosses into under-specification given the tool's unclear schema alignment.

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

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

This tool has no annotations, no output schema, and nine parameters that appear unrelated to the stated purpose. The description does not explain return values, parameter mapping, or invocation expectations. It is far from complete for an agent to use safely and correctly.

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

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

Although the schema has 100% description coverage, none of the nine parameters represents an arithmetic expression. The tool description mentions 'a+b style arithmetic' and 'Expression,' but no schema property maps to that expression. An agent cannot determine which parameter to populate to invoke the tool correctly, so the description adds no useful parameter semantics and actually creates a severe mismatch.

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

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

The description states a specific verb and resource: 'Evaluate a+b style arithmetic.' This clearly signals that the tool is for evaluating simple arithmetic expressions. However, it does not distinguish itself from sibling tools, and the phrase 'Expression discarded' adds ambiguity about whether a result is returned.

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

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

The phrase 'a+b style arithmetic' implies the tool is for arithmetic evaluation, providing some usage context. But there is no explicit guidance about when to prefer this tool over alternatives, no prerequisites, and no examples of appropriate 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?

No annotations are provided, so the description carries the behavioral transparency burden. 'Page content is not stored' is a useful non-obvious disclosure, but the description does not clarify whether a network request is made, what HTTP method is used, or what other data (such as the discarded parameters) may be touched.

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 redundant phrasing. The core behavior is front-loaded, and the privacy note 'Page content is not stored' earns its place by adding meaningful 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?

Given nine optional parameters, no output schema, no annotations, and a large sibling tool list, this two-sentence description is incomplete. It does not state which parameter to supply, what the return format is, or when this tool should be chosen over fetch-status or normalize-url.

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

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

The input schema already describes each parameter at 100% coverage, so the baseline is 3. The description adds context that the URL is the relevant input and what result is produced, but it does not clarify that the other eight parameters are irrelevant, even though their schema descriptions repeatedly say 'discarded.'

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

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

The description clearly states the action: 'Return host, scheme, and HTTP status for a URL.' This is a specific verb plus resource and gives the agent a clear sense of the tool's output. However, it does not explicitly differentiate this tool from URL-related 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?

The description implies a use case: when you need host, scheme, and HTTP status for a URL. It does not provide when-not-to-use guidance or mention any alternative tools, so selection among the many URL-focused siblings is left 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, and it does add some behavioral context: 'No identifiers are retained' implies an ephemeral, privacy-conscious operation and 'Show' suggests read-only behavior. Still, it omits details such as whether any external calls are made, what the output format is, or how failures are handled, leaving noticeable 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 very concise: two short sentences. The main action is front-loaded ('Show how this request is classified') and the privacy note is a separate meaningful sentence with no filler or repetition. Every word earns its place.

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

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

This tool has nine heterogeneous parameters, no output schema, and no annotations, yet the description does not explain how the parameters feed into 'classification,' what output the agent should expect, or how this tool relates to its many siblings. For a tool with such a broad input surface, the description is incomplete and leaves too much to inference.

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 fully documents all nine parameters with individual descriptions, so the baseline is 3. The tool description adds no parameter-level detail or relationships between parameters; it does not compensate or extend what the schema already provides.

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') and adds a privacy guarantee, so it is not a pure tautology. However, it does not define what 'classified' means, what classification categories exist, or how it differs from sibling tools like domain-shape or validate-json. The agent gets only a vague sense of the tool's 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 provided about when to use this tool instead of the many sibling shape/check tools. There are no stated conditions, exclusions, or alternatives. The description only says what the tool does, not when to select it.

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

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

With no annotations, the description carries the behavioral burden; it does disclose a meaningful limitation (no WHOIS/ownership data) and implies a pure parse via 'Split'. However, it does not state whether any network access occurs, whether inputs are discarded, or what error behavior to expect, leaving some behavior unspecified.

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

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

A single front-loaded sentence with no filler; the core operation and a key exclusion are stated immediately.

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

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

With nine parameters, no output schema, and no annotations, this one-sentence description is far from complete. It does not specify the expected output format, how to handle invalid hostnames, or which parameter combinations are valid, and it does not relate the many schema fields to the tool's purpose.

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 usefully maps to the 'host' parameter by saying 'hostname', but it adds no extra meaning about the other eight parameters or which parameter should be populated.

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

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

The description names a concrete operation ('Split a hostname into labels') and an explicit non-goal ('without WHOIS or ownership data'), so an agent can tell this is a syntactic domain parse rather than an enrichment lookup. It does not explicitly contrast with sibling shape tools like github-repo-shape or figma-url-shape, but the hostname resource is 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?

The description implies when to use the tool: when a hostname needs to be split into labels and WHOIS/ownership data is not needed. However, it does not name alternative tools or provide explicit when-not-to-use conditions, leaving the selection guidance mostly implicit.

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

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

With no annotations, the description carries the transparency burden and does disclose the HTTP method (HEAD) and the output scope (status only), implying a non-destructive, bodyless check. It does not mention redirect/error handling, response format, or how the many other schema fields are treated, so transparency is partial.

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

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

One sentence, no filler, and the core action, target, and output limitation are front-loaded. Every word earns its place.

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

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

For a tool with no output schema and no annotations, one sentence leaves too much unexplained: the return value is only vaguely 'status', the nine schema fields are not reconciled with the URL-only description, and no guidance distinguishes this from siblings. The description is too incomplete for safe, correct invocation across the tool's actual schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter detail beyond 'a public URL', while the nine optional fields are described in the schema but never reconciled with the URL-only claim.

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 'HEAD a public URL' as a specific verb+resource and narrows the output to 'status only', which clearly distinguishes it from content-fetching siblings like web-fetch. However, it doesn't explicitly say 'HTTP status code' or address why the schema lists nine unrelated optional parameters, leaving some ambiguity about the tool's actual scope.

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

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

The phrase 'public URL' and 'status only' imply lightweight reachability/status checks rather than full-content retrieval. But no explicit when-to-use or when-not-to-use guidance is given, and no sibling alternatives are named, so the usage context is only implied.

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 the path is discarded. It does not state whether the tool performs network access, returns a boolean or parsed object, errors on invalid URLs, or has other side effects.

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

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

Two short sentences with no filler. The core purpose is front-loaded and the second sentence adds a meaningful constraint. Every word earns its place.

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

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

There is no output schema and no annotations, so the description must explain expected inputs, outputs, and edge cases. It does not specify which parameter should contain the Figma URL, what a valid result looks like, or what happens with malformed or non-Figma URLs, leaving a nine-parameter optional schema under-explained.

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 input schema already documents each parameter. The description adds little beyond naming the target as a Figma file URL and noting that path is discarded, which is the expected baseline when schema descriptions are complete.

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 resource (Figma file URL) and action (parse), and the phrase "Path discarded" adds a scoping detail. It is distinguishable from sibling shape/URL tools, though it leaves what "parse" returns or validates implicit.

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 like normalize-url, domain-shape, or github-repo-shape. The intended context is only implied by the tool name and the phrase "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, the description must carry the burden, and it does explicitly disclose the key behavioral trait that the check involves no disk access. However, it does not explain what 'safe' means (e.g., traversal, absolute paths, null bytes), what the function returns, or whether it can throw. This is a useful but partial disclosure.

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

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

Two short sentences, no filler, and the most important operational constraint ('No disk access') is placed in its own sentence. It is arguably too terse for the tool's complexity, but as structure it is efficient and 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?

The tool has 9 parameters, no annotations, and no output schema, yet the description only states the general purpose and the no-I/O property. There is no return contract, no safety-criteria definition, and no guidance connecting the many parameters to the check. This is significantly incomplete 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 coverage is 100%, so every one of the 9 parameters already has its own description; the tool description adds no parameter-level semantics. Baseline 3 is appropriate because the description does not need to compensate, but it also contributes no extra param context.

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?

Clearly names the operation ('Check') and the resource ('a path') and adds a safety criterion ('looks safe'). The phrase 'No disk access' helps differentiate it from filesystem-touching checks and sibling URL checkers, though it does not explicitly contrast with 'browser-url-ok' or 'playwright-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 'No disk access' clause gives a clear context signal: this is a non-I/O validation, so it can be called when only path shape matters. But it does not state when to prefer it over alternatives, nor provide any exclusions or explicit 'use this instead of X' guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals only that the tool uses Open-Meteo, with no mention of network calls, side effects, error behavior, rate limits, or the fact that most inputs appear to be discarded.

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

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

The description is brief and front-loaded, with no filler. However, it is under-specified for a tool with nine parameters and no annotations, so the brevity is not fully appropriate to 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?

With nine parameters, no output schema, and no annotations, the one-sentence description is insufficient. It does not specify which parameter selects the place, what the return value looks like, or what failure modes exist, making it hard for an agent to invoke correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning and does not connect 'a place' to the city parameter among nine schema properties, leaving the agent to infer which input to supply.

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 core function—returning latitude and longitude for a place—and names the external service, Open-Meteo. It is reasonably clear but lacks an explicit verb and does not identify which input parameter represents the 'place', so it stops short of a top score.

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 weather-hint or other sibling tools. The description only implies use when coordinates are needed, but it does not state prerequisites, exclusions, or how to choose between geo-hint and related tools.

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

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

With no annotations, the description carries the full burden. It accurately describes the core parse behavior, but it does not disclose how malformed URLs are handled, whether git suffixes or trailing slashes are normalized, or that unrelated schema fields are ignored. The schema's 'discarded' notes add some context, but the description itself is minimal.

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

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

One sentence with no filler. The verb and target are front-loaded, and every word contributes to the meaning. This is appropriately concise.

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

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

The tool has 9 optional parameters and no output schema, yet the description only says 'parse owner and repo.' It does not specify the output structure or warn that most schema fields are irrelevant for this tool. For such a simple operation this is minimally viable, but the unrelated parameters create real ambiguity that the description does not resolve.

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?

Parameter schema coverage is 100%, so the baseline is 3. The description does not explicitly say the GitHub URL goes in the `url` parameter, but the parameter name and its schema description ('HTTPS URL to normalize or cite') make that mapping reasonably inferable. It adds no parameter-level detail beyond the schema.

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

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

The description states a specific action ('Parse') and a specific result ('owner and repo') for a specific input ('a GitHub URL'). This distinguishes it clearly from sibling shape tools such as jira-key-shape or figma-url-shape by naming the exact resource type.

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 normalize-url, domain-shape, or browser-url-ok. It does not mention that this is a syntactic parse with no network access, nor does it state any exclusion criteria for when not to use it.

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

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

With no annotations, the description must carry behavioral disclosure. It reveals only that titles are discarded; it doesn't state the return type, that it performs a live network fetch, or how failures or irrelevant parameters are handled.

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

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

Two short sentences, main action front-loaded, no filler. 'Titles discarded' is terse to the point of ambiguity but still earns its place as a behavioral hint.

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?

A tool with nine optional parameters and no output schema needs more than a purpose statement. The description omits the relevant parameter, return shape, network behavior, and whether no-argument invocation is supported, so an agent cannot reliably call it.

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's 'Titles discarded' aligns with the feed parameter's description but never tells the agent which of the nine optional parameters applies to 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?

Clearly states a specific action ('Count') and unique resource ('current Hacker News front-page stories'), which separates it from sibling fetch/count tools. The second sentence is cryptic, 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 information about when to choose this tool over web-fetch, fetch-status, or other siblings. It does not mention prerequisites, when-not-to-use, or input requirements.

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 disclosure burden. It does not say whether the tool returns a list, performs a lookup, mutates anything, or ignores parameters. The description provides no behavioral traits beyond the tool name itself.

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 concise. A six-word noun phrase is not appropriately sized for a tool with nine diverse parameters and no output schema; it does not earn its place by providing usable operational 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?

Given nine optional parameters, no annotations, and no output schema, this description is far from complete. It does not explain what the agent should expect as a result, how the parameters relate to IANA timezone names, or what 'clock calls' means in this context.

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

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

Schema coverage is 100%, so the schema's parameter descriptions carry the semantic weight. The tool description adds no parameter-level meaning, but the baseline of 3 applies because there is no gap in schema documentation to compensate for.

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 'Common IANA timezone names for clock calls' rather than a statement of what the tool does. It largely restates the tool name ('IANA timezone names' ≈ 'iana-zones') and adds only a vague reference to 'clock calls' without specifying an operation such as returning, listing, or validating.

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' hints at a context, but it does not explicitly say when to use this tool versus siblings like 'timezone' or 'utc-time'. No alternatives or exclusions are mentioned, so an agent receives almost no routing guidance.

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

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

With no annotations provided, the description carries the full transparency burden. It does disclose the network fetch and the limited 'group counts only' return shape, but it omits error behavior, redirects, what exactly constitutes a group, and external-host contact implications.

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. However, for a tool with nine parameters and no annotations, it is undersized; the conciseness is good but the structure does not accommodate necessary detail.

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

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

The description is incomplete for a nine-parameter tool with no output schema and no annotations. It does not identify the required input, what 'group counts' means, how errors are surfaced, or how the provided parameters relate to fetching robots.txt.

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

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

Although schema coverage is 100%, the description gives no mapping from the nine schema properties to the robots.txt target. The schema descriptions are generic and unrelated: 'HTTPS URL to normalize or cite,' 'File path to check,' 'JSON text to validate.' An agent cannot tell which parameter supplies the robots.txt URL, so the description fails to add needed meaning.

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: 'Fetch a public robots.txt' and limits the output to 'group counts only.' This clearly distinguishes it from siblings like web-fetch, fetch-status, and normalize-url, which do not target robots.txt group counts.

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

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

There is no guidance on when to use this tool versus siblings like web-fetch, browser-url-ok, or normalize-url. No when-not-to-use context or alternative tool routing is provided; usage is only implied by the resource 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 provided, the description carries the full burden of behavioral disclosure. It only says 'Key discarded,' which hints that input is not retained, but it omits the return value, validation result semantics, error behavior, and whether any network or external lookup occurs. 'Check' implies a read-only operation, but that is not made explicit.

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 no filler. 'Check a Jira issue key shape' is an efficient statement of purpose, and 'Key discarded' is a terse behavioral note. However, the extreme brevity borders on under-specification, which prevents a perfect score.

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

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

For a validation tool with no output schema and no annotations, the description should explain at least what input represents the key, what shape is expected, and what the caller receives. None of that is provided. The description is only a name expansion, not enough for an agent to invoke the tool correctly.

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

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

The schema has seven parameters with individual descriptions, but none of them is named 'key' or explicitly mapped to the Jira key being checked. The description adds no meaning to the parameters and leaves the agent guessing which field (ref? url?) actually contains the key. High schema coverage does not help when the central parameter is not identified.

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

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

The description states a specific verb and resource: 'Check a Jira issue key shape.' This makes the core function clear and distinguishes it from sibling shape-checkers such as github-repo-shape or domain-shape. However, it does not define what constitutes a valid Jira key shape, so exact behavior is left implicit.

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 sibling shape-check tools, nor any mention of prerequisites or expected input context. The purpose is inferable from the name and first sentence, but the description does not actively route the agent to the correct choice.

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

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

No annotations are provided, so the description carries the full burden. It does disclose 'Body discarded,' which is useful, but it omits other essential behavioral traits such as whether a network request is made, the response format beyond 'HTTP status,' and how failures are handled.

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

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

The description is one short, front-loaded sentence with no filler. However, it is so terse that it under-delivers on needed context, so it loses a point for not being appropriately sized.

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

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

This is a nine-parameter tool with no output schema and no annotations, yet the description only covers one apparent mode. An agent cannot determine which parameter to use for different hint checks, what the return value looks like, or when this tool is appropriate relative to the extensive sibling list.

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's parameter descriptions cover 100% of parameters, so the baseline is 3, but the tool description actively narrows the tool to a URL-only purpose while the schema exposes nine heterogeneous parameters (city, feed, json, path, query, etc.). This mismatch makes it harder, not easier, for an agent to understand which parameters are relevant for a given call.

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

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

The description states a specific operation: returning the HTTP status for a public library docs URL and discarding the body. This is clear about the core action, but it does not distinguish the tool from sibling status/URL tools 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?

There is no guidance on when to use this tool versus alternatives, no exclusions, and no mention of prerequisites. The phrase 'public library docs URL' implies one use case, but the agent is left guessing how this differs from other URL/status tools.

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

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

The phrase 'Values discarded' adds a meaningful behavioral detail beyond the tool name: the result is a count, not the values themselves. However, with no annotations provided, the description does not disclose whether the input is stored, whether the operation is side-effect-free, or how invalid JSON is handled.

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

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

The description is only two short sentences and contains no filler. The core action is front-loaded and every word adds 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?

Given no output schema and no annotations, the description is under-specified. It does not identify which parameter supplies the JSON object, whether nested keys are counted or only top-level keys, or what the output format is beyond implying a count. This is inadequate for a tool with nine 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?

Although the schema documents all 9 parameters, the descriptions do not align with the stated purpose. For example, the 'json' parameter is described as 'JSON text to validate', not as the object whose keys are counted, and the other eight parameters appear unrelated. The description never maps 'JSON object' to a specific parameter, leaving an agent unsure how to construct a correct call.

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

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

The description states a specific action ('Count keys'), a specific resource ('a JSON object'), and an important outcome ('Values discarded'). This clearly distinguishes it from sibling tools like validate-json, which validates rather than counts.

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 number of keys in a JSON object. However, it does not explicitly say when not to use it, nor does it mention alternatives such as validate-json or other shape-checking siblings.

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

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

With no annotations, the description carries the behavioral-disclosure burden. It does disclose that query and fragment are dropped, which is key behavior beyond the schema. However, it does not clarify whether the many unrelated parameters in the schema are ignored or discarded, leaving ambiguity about side effects and parameter handling.

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

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

The description is two short sentences with no filler: the first states the main output, and the second states the dropped components. It is front-loaded and every word earns its place.

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

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

Despite having nine parameters, no output schema, and no annotations, the description provides only two sentences. It lacks guidance on which parameter to pass, how the returned origin/host/path are formatted, and what happens with apparently irrelevant schema fields, making the definition 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 each parameter already has a description. The tool description adds little about parameter meaning beyond implying the url parameter is the primary input. It does not help an agent choose among the nine largely unrelated-looking parameters, so the baseline of 3 is appropriate.

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

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

The description states a specific action (return origin, host, and path) and a clear resource (a URL), which is immediately understandable. It does not explicitly differentiate from sibling URL tools, but the output list and normalization focus make the tool's role clear enough.

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 cases where only the normalized origin/host/path are needed and query/fragment should be dropped, but it gives no explicit when-to-use or when-not-to-use guidance. There are no named alternatives or exclusions beyond the URL component behavior.

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 disclosure burden. It discloses only that no browser is launched, but does not state whether a network request is made, whether the operation is read-only, what failure modes exist, or what the returned result looks like.

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

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

The description is very short and free of filler. The two sentences each add information: the core purpose and a key behavioral caveat. It is appropriately front-loaded, though more structural detail about return behavior and parameter usage would help.

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

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

This tool has 9 parameters, no annotations, and no output schema, yet the description explains almost none of the operational context. An agent cannot determine what result to expect, which parameter is relevant for a given request, or how this relates to sibling URL-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?

Schema description coverage is 100%, so the baseline is 3. Every parameter is individually described in the schema, including discard behavior, so the tool description does not need to repeat parameter meaning. It adds no parameter-level detail beyond the URL focus, but the schema already covers that ground.

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 URL can be opened.' The added phrase 'No browser is launched' gives a distinguishing behavioral detail, especially relative to the sibling browser-url-ok. However, 'can be opened' is somewhat vague about whether this is URL syntax validation, an HTTP reachability check, 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 about when to use this tool versus siblings like browser-url-ok, normalize-url, fetch-status, or web-fetch. The 'No browser is launched' phrase offers a hint, but no alternatives or selection conditions are 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?

Because no annotations are provided, the description carries the full behavioral burden. It does disclose that the query is discarded and that the operation is a character count, but it omits the return shape, encoding or edge-case behavior, and what happens with the other eight accepted parameters. Thus it gives partial 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 two short sentences with no filler, and the most important action is front-loaded in the first sentence. 'Query discarded' is a separate, useful behavioral note that earns its place.

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

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

With nine optional parameters, no output schema, and no annotations, a one-line description leaves too much unspecified: return value, how the extra fields relate to the tool, and edge cases such as empty input. The schema documents each property, but the description does not connect them to the tool's purpose, making agent-side reasoning 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 coverage is 100%, so the baseline is 3 even without parameter information in the description. The description emphasizes 'search query' as the relevant input, but it never names the 'query' property explicitly or explains the other eight string parameters, which remain optional in the schema. It adds only marginal meaning beyond the schema.

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

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

The phrase 'Count characters in a search query' names a specific verb and resource, and 'Query discarded' adds a side-effect note. However, it does not contrast with related sibling tools or clarify which schema field is the query, so it stops short of full differentiation.

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

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

There is no statement about when to prefer this tool over the many sibling count/check tools, and no exclusions or alternatives are named. The only implied context is the tool name, so an agent gets no routing guidance.

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

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

There are no annotations and the description discloses no behavior: no mention of side effects, network access, data retention, errors, or what happens to the seven input parameters. The schema hints that values may be discarded, but the description itself carries none of that burden; an agent cannot anticipate the tool's behavior.

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

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

The description is short but this is under-specification, not efficient conciseness. It spends no words on the operation or selection criteria, so the brevity comes at the cost of usefulness.

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 optional-looking parameters, no output schema, no annotations, and sibling tools for fetching or checking statuses, this description is far from complete. An agent has no idea what arguments to supply or what response to expect.

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

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

The input schema already describes all seven parameters, so schema description coverage is high and the baseline is 3. The description itself adds no parameter meaning, but it also does not need to compensate because the schema is complete.

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 essentially a noun phrase: 'Short catalog of common HTTP status codes' restates the tool name without a verb or operation. It does not say whether the tool returns a list, looks up a code, or validates something, and it fails to distinguish status-catalog from siblings like fetch-status.

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

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

The one-line description gives no when-to-use or not-to-use guidance. There is no mention of alternatives such as fetch-status, no exclusions, and no context for when this catalog should be preferred.

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

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

No annotations are present, so the description carries the full burden. It transparently discloses the key behavioral trait: the prompt/input is discarded and only a fixed template is returned. This prevents an agent from expecting the parameters to affect the output. It does not mention side effects, but for a simple template-returning tool this is likely 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 two short sentences with no filler. The main purpose is front-loaded, and the important caveat about the discarded prompt follows immediately. Every sentence contributes useful information.

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

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

For a tool with all-optional parameters that are described as discarded or check-only, the description covers the essential behavior: it returns a fixed three-step template. The lack of an output schema leaves some ambiguity about the exact template format, but the behavior is simple enough that nothing critical for invocation is 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?

Schema coverage is 100%, so the baseline is 3. The description adds only the general note that the prompt is discarded, while the schema already documents each parameter's discard-or-check behavior. No additional parameter-level meaning is provided beyond the schema.

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

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

The description states a concrete action and object: 'Return a three-step thinking template.' It also clearly warns that the prompt is discarded, so the agent understands this is a fixed-output template utility. It does not explicitly differentiate from sibling tools, but the unique template-returning behavior is enough to distinguish it.

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 statement about when to use think-steps versus sibling tools. The phrase 'Prompt discarded' implies that inputs do not influence the result, which gives some context, but no when-to-use or when-not-to-use guidance 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the tool returns the current time; it does not describe output format, invalid timezone handling, read-only status, or any other behavioral traits.

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

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

The description is a single concise sentence with no filler or unnecessary words. It is front-loaded with the core function, though it is terse to the point of leaving contextual gaps addressed 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?

Given the 9-parameter schema with several unrelated, 'discarded' inputs and the absence of an output schema, a single sentence is not enough context. The description does not explain which parameters are relevant, what the return value looks like, or how this tool relates to its siblings.

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 parameter descriptions already document the relevant IANA timezone name fields. The description adds little beyond the word 'named', which loosely corresponds to the schema's 'IANA timezone name' descriptions, but does not clarify which of the 9 parameters should be used.

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

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

The description states a clear function: return the current time for a named IANA timezone. It is specific about the resource and scope, though it does not directly differentiate itself from sibling tools like utc-time 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?

No guidance is provided about when to use this tool versus alternatives such as utc-time or iana-zones. There are no exclusions, conditions, or examples, so the agent must infer usage entirely from the tool name and description.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only names the output and gives no information about return format, precision, or the fact that the input parameters appear irrelevant to the tool's function.

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 or redundancy. It is front-loaded and appropriately spare for a trivial tool, though it omits a few important details best handled 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?

Given no output schema or annotations, the description should clarify what format the timestamp is returned in (e.g., ISO 8601 or Unix epoch) and whether the listed inputs are ignored. Without that, an agent cannot reliably know how to invoke the tool or interpret its result, especially with eight seemingly irrelevant 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 provides descriptions for all eight parameters, so schema coverage is high and the baseline is satisfied. The tool description itself adds no parameter semantics, and the schema properties appear to be unrelated shape-check/validation fields with some labeled as discarded, which can confuse rather than clarify whether any input is needed.

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

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

The description clearly states the output is the current UTC timestamp, which is specific enough for an agent to know what the tool produces. It doesn't distinguish itself from sibling tools like timezone or iana-zones, but there is little ambiguity in the core purpose.

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

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

Usage is implied: an agent should call it when it needs the current UTC time. However, there is no explicit when-to-use/when-not-to-use guidance or mention of alternatives such as timezone, so the routing decision is left 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 present, the description carries the burden of behavioral disclosure. It usefully states that the body is discarded after the check, implying no retention or side effects. However, it does not describe the return format, error behavior, or what 'valid' means beyond basic JSON syntax.

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 wasted words. It communicates the core purpose and the key side-effect efficiently.

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

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

For a simple validation tool, the description plus schema is mostly sufficient, but the term 'body' does not map directly to any schema property, and the purpose of the many unrelated parameters is left unexplained. The lack of an output schema and absence of usage guidance leave room for agent uncertainty about return values and invocation.

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

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

The input schema descriptions fully cover all seven parameters, including the 'json' parameter as 'JSON text to validate; discarded after the check.' The description adds no parameter-level meaning beyond the schema, so the baseline of 3 applies.

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

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

The description states a specific action ('Check whether a body is valid JSON') that clearly identifies the tool's core function. It distinguishes the tool from sibling validators through the explicit JSON focus, though 'body' is slightly ambiguous compared to the schema's 'json' parameter.

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

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

No guidance is provided about when to use this tool versus alternatives like domain-shape or file-path-ok. The description implies 'use this when you need to validate JSON,' but it does not state exclusions, alternatives, or context for choosing among related validators.

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

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

No annotations are present, so the description carries the full burden. It adds 'via Open-Meteo', implying an external network call, but it does not disclose what the tool returns, whether it can fail, or that most provided parameters are simply discarded. This is a significant transparency gap for a tool with no structured behavioral hints.

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 or repetition. It conveys the core purpose and external source economically, earning a high conciseness score even though it lacks supporting detail.

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

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

With nine optional parameters, no output schema, and no annotations, this short description is insufficient for an agent to invoke the tool correctly. It does not state which parameter to populate, what output to expect, or what happens when no city is provided. The schema covers parameter names, but the tool-level behavior and return contract remain underspecified.

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 explains every parameter. The tool description adds only that city is the relevant weather input, but it does not clarify how the other eight parameters relate to the tool's purpose. The high coverage supports the baseline 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 clear, concrete operation: returning the current temperature for a city, and names the external provider (Open-Meteo). It is easy to distinguish from more generic siblings like geo-hint or timezone, 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?

There is no guidance about when to choose weather-hint over alternatives, nor any mention of required inputs or limitations. The only implicit signal is that a city is involved, but the description does not say which parameter to use or that many schema fields are ignored.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It usefully states that the body is discarded and that the URL must be public. However, it does not describe network semantics such as whether it performs a GET request, follows redirects, or has no side effects.

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

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

The description is extremely concise, with only two sentences and no wasted words. The primary outcome is stated first, and the secondary behavioral note about the body being discarded is clearly separated and relevant.

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

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

Given nine optional parameters, no required parameters, no output schema, and no annotations, the description is far too sparse. It does not explain the return format, which parameters actually drive the fetch, or how the other parameters should be treated, leaving an agent without enough information to invoke the 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?

The input schema has high description coverage (100%), so the baseline is 3. The description adds meaning for the URL parameter by tying it to HTTP status/content type, but it does not clarify how the other eight optional parameters relate to the stated purpose, leaving potential 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 states the tool's core outcome: it returns HTTP status and content type for a public URL. 'Body discarded' adds useful specificity. However, it does not differentiate this tool from siblings like fetch-status or browser-url-ok, whose purpose overlaps.

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 web-fetch versus the many sibling tools. It implies a use case for checking a public URL, but does not mention exclusions, alternatives, or which sibling should be chosen for other URL-fetching needs.

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

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

With no annotations, the description carries the behavioral burden. It does disclose one useful trait beyond the schema: 'Title discarded after the call.' However, it does not state the return type, whether a network lookup is performed, or what happens when the title does not 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 two short sentences with the purpose front-loaded and the discard behavior called out separately. Every clause earns its place and 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?

For a tool with seven loosely related optional parameters and no output schema, the description is insufficient: it does not say which parameter carries the Wikipedia title, what the return looks like, or when to prefer this tool over sibling checks. The discard note is the only extra context preventing a lower score.

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 seven parameters in detail, so the high schema coverage sets a baseline of 3. The description adds no parameter-level meaning and, more problematically, refers to a 'title' that does not map to any property in the input 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 uses a specific verb ('Check') and resource ('whether a Wikipedia title exists'), so the core operation is clear. However, it does not differentiate from sibling validation tools, and it introduces a 'title' concept that does not appear in the input schema.

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

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

The description gives no guidance about when to use this tool versus alternatives such as browser-url-ok, validate-json, or domain-shape. No exclusions, prerequisites, or routing conditions are provided; the only usage signal is implicit in the purpose statement.

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