Australia/Brisbane clock

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

There are no annotations, so the description carries the behavioral disclosure burden. It explicitly states 'Task text discarded' and the schema descriptions reinforce that several inputs are discarded after the shape check/call. This provides meaningful transparency about input handling, though it does not cover auth, rate limits, or side effects beyond the discard behavior.

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

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

The description is two sentences with no wasted words. The first sentence names the action and target, and the second lists outputs plus the key behavioral caveat. It is efficiently front-loaded and easy to parse.

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 discovery/lookup tool, the description is largely complete: it names the target, enumerates return outputs, and discloses the input-discard behavior. There is no output schema or annotations, so the return-value enumeration is valuable. It could add more about when to invoke it, but the core calling context is present.

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

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

The input schema already documents all six parameters with descriptions, so schema coverage is 100%. The tool description adds little about parameters themselves; 'Task text discarded' is not tied to a specific schema property. Baseline 3 is appropriate because the schema does the heavy lifting.

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

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

The description states a specific action ('Find a public pay-per-call tool gateway') and identifies the resource (Monid), then lists the four return artifacts (CLI setup, how-it-works, skill file, remote MCP hops). It is clear about what the tool does, though it does not explicitly contrast it with 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 implies that this tool is for locating a Monid pay-per-call gateway and retrieving associated setup/hop information. However, it gives no explicit guidance about when to use this tool instead of a sibling, nor any conditions, prerequisites, or exclusions.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It does reveal one useful behavior—no browser is launched—but it does not explain whether the check is a network request or local parsing, what side effects might occur, or how results are returned. This falls short for a tool with zero annotation support.

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

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

The description is extremely compact, with two short sentences where each adds distinct value: the first states the operation and the second states a key behavioral boundary. It is front-loaded and contains 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?

Given the tool's seven input parameters and the large sibling context, the description is too thin to fully support invocation. It does not explain how to select among parameters, what the return value represents, or how this check relates to alternatives like normalize-url or fetch-status.

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 descriptions for all seven parameters, so schema coverage is high and the baseline is 3. The description itself adds no parameter-specific meaning and does not clarify how the URL parameter relates to the other parameters, but the schema descriptions already carry most of the parameter-semantics burden.

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

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

The description clearly states a specific action on a resource: 'Check whether a URL can be opened.' It also adds a meaningful differentiator, 'No browser is launched,' which helps distinguish it from browser-based tools like playwright-url-ok. However, the schema contains several unrelated parameters (json, city, ref, path), making the stated URL-only scope slightly 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?

The phrase 'No browser is launched' implies this tool is appropriate when a lightweight URL check is desired without full browser automation, but this guidance is only implicit. The description does not explicitly name alternatives or state when not to use this tool versus siblings like fetch-status or web-fetch.

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

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

The only disclosed behavior is 'Expression discarded', which is confusing rather than informative. With no annotations available, the description carries the full burden of explaining side effects, return values, and whether this is a read-only check. It fails to do so.

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

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

The description is very short, but this is under-specification, not effective conciseness. The two sentences conflict with each other and leave the tool's core contract unexplained.

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 ten parameters, no annotations, and no output schema, this description is far from adequate. It omits the actual parameter to use, the expected return value, and the tool's real purpose, making successful invocation unlikely.

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 describes each parameter individually, so baseline coverage is high, but the description introduces an 'expression' concept that is absent from the schema. It does not tell the agent which of the ten parameters to provide or how they relate to arithmetic evaluation.

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

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

The description names a specific operation ('Evaluate a+b style arithmetic'), but immediately undercuts it with 'Expression discarded' and the input schema contains no arithmetic expression parameter. An agent cannot tell what this tool actually accepts or computes, and the wording is more misleading than clarifying.

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

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

There is no guidance on when to use this tool, when not to use it, or which sibling tools are alternatives. The schema's many unrelated parameters provide no context for selecting calc-eval over tools like validate-json or domain-shape.

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 add a meaningful privacy/retention note: 'Page content is not stored,' and 'Return ... HTTP status' implies an outgoing read-only request. However, it does not mention potential side effects, authentication needs, rate limits, or failure behavior, so transparency is only partially addressed.

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 with no filler. The primary behavior is front-loaded, and the second sentence adds a concise, valuable privacy note. Every part earns its place.

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

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

Despite the concise core, the tool has nine optional parameters with no required ones, and the description does not clarify which parameter is the actual operational input or that the other parameters are effectively ignored. Without an output schema or annotations, an agent may be uncertain how to invoke this tool correctly, especially given the many sibling tools with overlapping URL-checking capabilities.

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 all nine parameters, including their meanings and discard behavior. The description mentions 'URL' only at a general level and adds no parameter-specific detail, so it neither improves nor harms semantics beyond the schema 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 states a concrete action and output: 'Return host, scheme, and HTTP status for a URL.' This is specific enough to distinguish it from vague 'process' tools, and the phrase 'for a URL' clarifies the resource. However, it does not explicitly differentiate from siblings like fetch-status or normalize-url, so it falls 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 gives no guidance about when to use this tool versus the many sibling tools, such as fetch-status, browser-url-ok, or normalize-url. There are no exclusions, prerequisites, or alternative conditions mentioned, leaving the agent to infer the use case from the tool name and description alone.

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

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

No annotations are provided, so the description carries full behavioral disclosure burden. The statement 'No identifiers are retained' adds a useful privacy/retention trait, but it omits other behavioral details such as whether network calls are made, what side effects exist, or how the classification result is returned.

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

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

The description is short and to the point, with no wasted words. Its two sentences front-load the core action and then add the privacy statement, though the first sentence is somewhat vague.

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

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

With no output schema and no explanation of return values or classification semantics, the description is incomplete for a tool that classifies requests. The purpose is ambiguous and there is no guidance on what an agent should expect after calling 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?

The input schema already provides descriptions for all seven parameters, including discard behavior for ref, city, and json. The tool description adds no parameter-level meaning beyond that, so the schema is doing the heavy lifting.

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

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

The description uses a verb 'Show' and a resource 'request', but 'how this request is classified' is vague: it never defines what classification means or what output is produced. It also does not differentiate the tool from sibling shape-check or hint tools such as domain-shape or github-repo-shape.

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

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

No guidance is given about when to use this tool versus alternatives, no explicit conditions or exclusions, and no mention of which sibling tools overlap. The privacy note is implicit context but does not tell an agent how to select or invoke the tool.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does add one meaningful constraint: the tool avoids WHOIS/ownership data. Yet it does not state whether the operation is purely local string parsing, how invalid hostnames are handled, or what the output structure is, so behavioral transparency is only partially covered.

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 sentence that is directly informative and front-loaded. The core action comes first, and the restriction 'without WHOIS or ownership data' is a meaningful addition with no filler.

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

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

The description is sufficient for a very simple split operation, and 'into labels' hints at the return shape. However, there is no output schema, no explicit statement that 'host' is the required input, and no guidance on how ignored schema fields should be handled, leaving some room for agent uncertainty.

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

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

The input schema already documents all seven parameters, including 'host' as 'Public hostname', so schema coverage is high. The description adds no extra parameter-level detail and does not explicitly say that 'host' is the relevant field or that the other parameters are ignored 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 names a specific verb, 'Split', and a concrete resource, 'a hostname', with a clear result: 'labels'. The phrase 'without WHOIS or ownership data' helps distinguish it from lookups, but it does not reference any sibling tool explicitly, so it stops short of full sibling-level 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?

The description implies when to use the tool: when only the structural labels of a hostname are needed, not ownership or WHOIS metadata. However, it does not name alternatives (e.g., normalize-url, web-fetch) or state when to prefer those instead, leaving the routing decision 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 transparency burden. It does disclose the HTTP method (HEAD), the target kind (public URL), and the limited output (status only). It does not explain redirects, failure behavior, or why the schema contains many unrelated parameters, leaving significant behavioral 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 description is a single efficient sentence with no filler and front-loads the method and output. It is slightly too terse for the complexity of the parameter schema, but it earns its place.

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

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

The tool has nine optional parameters, no annotations, and no output schema. A one-line description is insufficient for an agent to know which parameters to supply, what the returned status looks like, or what happens on failure. It is only adequate for a trivial url-only call.

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

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

Schema description coverage is 100%, so each parameter already has an explanatory description; the baseline is therefore 3. The description adds the connection between the 'url' parameter and the HEAD operation, but it does not clarify how the other eight optional parameters relate to the stated URL-status purpose.

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

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

The description states a specific verb and resource: HEAD a public URL and return status only. This clearly distinguishes it from content-fetching tools like web-fetch. However, the input schema lists many unrelated optional parameters, so the description does not fully clarify what the tool is actually scoped to handle.

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

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

'Return status only' implies the tool should be used when HTTP status is needed instead of page content, but no alternative tools are named and no explicit when-to-use/when-not-to-use conditions are given. The agent is left to infer the intended usage 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 provided, so the description carries the full burden of behavioral disclosure. It does reveal one behavior ('Path discarded'), but it does not state whether parsing validates, normalizes, extracts components, or performs any network request. The return behavior and side effects are completely 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?

The description is two very short sentences with no filler, and the core purpose is front-loaded. The fragment 'Path discarded' is compact but cryptic; nonetheless, every word earns its place. It is appropriately sized for a terse tool description.

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

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

With 9 optional parameters, no required parameters, no output schema, and no annotations, this one-line description is far too thin. It does not say which parameter to pass, what the parsing result looks like, or how invalid input is handled. An agent cannot reliably determine how to invoke this tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds only that a Figma file URL is parsed and the path is discarded, which hints that `url` is the relevant input but does not clarify the role of the other 8 optional parameters. It does not compensate for the schema's generic, unrelated-looking parameter descriptions.

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

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

The description states a specific verb ('Parse') and resource ('a Figma file URL'), and adds a narrowing detail ('Path discarded'). The Figma-specific scope distinguishes it from generic URL siblings like normalize-url and web-fetch. It is not a tautology and gives more than the tool name.

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

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

The description implies when to use the tool: when you have a Figma file URL to parse. However, it provides no explicit alternatives or exclusion conditions. Among the URL-related siblings, it does not say why figma-url-shape should be chosen over normalize-url or browser-url-ok.

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. 'No disk access' is genuinely useful and tells the agent this is a side-effect-free syntactic check. However, it does not disclose the return value, define what 'safe' means, or clarify whether the many unrelated schema parameters are 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?

Two short sentences with zero filler. The core action is front-loaded, and the key behavioral constraint ('No disk access') is stated immediately. It is exemplary in compactness, though some of that brevity creates completeness gaps.

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 are no annotations, no output schema, nine optional heterogeneous parameters, and a sibling list full of other shape validators. The description does not state the output contract, what counts as 'safe', or which parameter to populate, so an agent has too much left to infer 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 schema already documents every parameter, which meets the baseline. The description aligns with the 'path' parameter ('File path to check') but provides no extra meaning and does not explain why the schema also contains ref, feed, zone, query, and other seemingly unrelated fields.

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

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

The description uses a specific verb and resource: 'Check whether a path looks safe.' This clearly identifies a path-validation predicate, and 'No disk access' further distinguishes it from filesystem operations. It does not name sibling tools, but the path focus is enough to differentiate it from URL/JSON/wiki validators.

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

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

There is no guidance about when to use this tool versus alternatives like wiki-title-ok, browser-url-ok, or validate-json. The description implies a pure shape check, but it never states exclusions, prerequisites, or which sibling would be preferred for other input types.

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 bears the full burden of disclosing behavior, but it only mentions the external Open-Meteo source and the output concept. It does not mention read-only/non-mutating behavior, error conditions, approximate results, or the fact that the schema shows many inputs are discarded after checks.

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

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

The description is a single, front-loaded sentence with no filler words or repetition. It is concise, though concise to the point of leaving out important usage and parameter mapping guidance.

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 large, mixed-purpose input schema and the absence of an output schema or annotations, this one-line description is not complete enough for reliable invocation. An agent cannot tell which parameter to pass, what the output shape is, or how failures behave.

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 each property, so the schema-coverage baseline applies; the description itself adds little parameter meaning. The only connection it implies is that 'a place' likely maps to the city property, but it never says so explicitly, and most schema properties appear unrelated to geocoding.

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 returns latitude and longitude for a place using Open-Meteo, which distinguishes it from siblings like weather-hint or timezone. However, it is phrased as a noun fragment rather than an explicit verb, and it does not name the input parameter that identifies the place.

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 geo-hint versus alternatives such as weather-hint or normalize-url. There are no conditions, exclusions, or references to sibling tools, so an agent must infer when this tool is appropriate.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It states the parse behavior but does not describe output shape, invalid-URL handling, or failure behavior. For a pure parse operation this is a minor but real 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. Every word earns its place and the core action and target are immediately clear.

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

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

The schema covers the parameters well and the tool is conceptually simple. However, with no output schema and no annotations, the description omits the return shape and behavior on non-GitHub or invalid URLs, leaving an agent slightly under-informed.

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

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

The schema already documents all parameters (100% coverage), providing a baseline of 3. The description adds meaning by specifying that the URL should be a GitHub URL, which the schema's generic 'HTTPS URL to normalize or cite' does not state.

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 ('Parse') and a specific resource ('owner and repo from a GitHub URL'). It clearly distinguishes this tool from sibling shape tools like domain-shape, figma-url-shape, and jira-key-shape.

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

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

The description clearly implies when to use this tool: when you have a GitHub URL and need to extract the owner and repository. It does not explicitly name alternatives or exclusions, but the narrow 'GitHub URL' condition provides clear 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 provided, so the description carries the burden. It discloses one meaningful behavioral trait—titles are not returned—and implies a live fetch of the current front page. It does not state the return format, network dependency, or any rate-limit/caching behavior, so transparency 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 contain the essential action and a useful limitation with no filler. The description is front-loaded and appropriately sized for a simple count 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?

The description is understandable for a no-argument count operation, but with no annotations and no output schema it leaves the return shape and invocation assumptions implicit. The unrelated optional parameters in the schema create potential confusion that the description does not fully 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?

Schema description coverage is 100%, so every parameter is already documented and the baseline is 3. The description adds no parameter guidance, and the nine optional parameters look unrelated to the HN-count purpose; still, the schema itself is individually descriptive.

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

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

The description clearly identifies a specific action and resource: counting current Hacker News front-page stories. The note 'Titles discarded' also sets expectations, but it does not explicitly differentiate from sibling tools such as web-fetch or wiki-title-ok.

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

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

The description implies the tool should be used when a count of Hacker News front-page stories is needed, and 'Titles discarded' warns that it is not for retrieving story titles. However, it names no alternatives and gives no explicit when-to-use or 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?

There are no annotations, so the description carries the full burden of disclosing behavior. It does not state what the tool returns, whether it is read-only, or any side effects. The only behavioral hints appear in the schema parameter descriptions (e.g., 'discarded after the shape check'), but these are not part of the tool description and are not sufficient to understand the tool's overall 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 extremely short, but it is under-specified rather than economical. It is a fragment that omits a verb and substantive operational detail. It does not earn its place because it fails to convey enough information to be useful.

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 parameters that appear unrelated to timezone names, no output schema, and only a one-line pointer to 'clock calls.' An agent cannot determine what inputs to provide, what operation will be performed, or what response to expect. This is severely incomplete for a tool of this apparent complexity.

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

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

All seven parameters have individual descriptions in the schema, so schema_description_coverage is high (>80%), warranting a baseline of 3. The description itself adds no parameter-level meaning and does not bridge the gap between the stated timezone purpose and the heterogeneous parameters. However, per the rubric, the baseline holds because the schema already documents the parameters.

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

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

The description, 'Common IANA timezone names for clock calls,' is a noun phrase that lacks an explicit verb or actionable statement. It doesn't clarify whether the tool lists, validates, or returns timezone names, and it fails to distinguish itself from sibling tools like 'timezone' and 'utc-time' that also relate to clocks. The input schema params (ref, url, city, feed, host, json, path) seem entirely disconnected from timezone names, further clouding the purpose.

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

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

The description gives no guidance on when to use this tool versus alternatives. It only says 'for clock calls,' which is too vague to route an agent. No alternative tools, exclusions, or conditions are mentioned, leaving the agent without any decision support.

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

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

With no annotations, the description carries the full burden for behavioral disclosure, but it only reveals that the operation fetches a public file and returns counts. It does not mention error behavior, redirects, rate limits, network assumptions, or what happens when the robots.txt is missing, and it gives no indication of side effects beyond the read.

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 appropriately front-loaded and compact, with no wasted words. However, it is so terse that it omits the parameter mapping and any usage context, so the economy comes at the expense of necessary 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 no annotations, no output schema, and a confusingly broad input schema, one sentence is materially insufficient. The definition does not tell the agent how to identify the target URL, what the returned group counts look like, or how to handle failures.

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 description does not indicate which of the eight schema parameters supplies the robots.txt URL; only 'url' or 'host' are plausible candidates, and their schema descriptions are about normalization/citation or a generic hostname. Several parameters (ref, city, json, path) are described as discarded checks unrelated to robots.txt, so an agent cannot infer how to invoke this tool correctly from either the description or the schema.

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

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

The description names a concrete action ('Fetch'), a resource ('public robots.txt'), and the exact result ('group counts only'), which is easy to understand and distinguishes it from generic web fetchers. However, it does not explicitly contrast it with sibling tools like domain-shape or web-fetch, 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?

No guidance is given about when to use inspect-robots versus alternatives such as web-fetch, fetch-status, or domain-shape. The phrase 'public robots.txt' is the only context cue; there are no exclusions, prerequisites, or alternative conditions.

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

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

There are no annotations, so the description must carry the behavioral burden. It does disclose that the key is discarded, which is useful, but it omits what happens on valid versus invalid keys, what the return value is, and whether any other side effects occur.

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. However, the extreme brevity sacrifices essential details about how to invoke the 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?

The tool has 7 parameters, no annotations, and no output schema, yet the description fails to identify which parameter is the Jira key. This is a critical gap: an agent cannot correctly select and invoke the tool based on the provided information.

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 descriptions cover all 7 properties, so the baseline is 3, but the description adds no mapping between 'Jira issue key' and any parameter. Moreover, the schema contains no obvious Jira-key parameter: 'ref' is labeled as a Git ref, and other fields cover weather, RSS, JSON, and URLs, leaving an agent unable to determine which parameter 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 names a specific verb ('Check') and resource ('Jira issue key shape'), so the core purpose is clear. It does not explicitly distinguish itself from sibling shape tools like github-repo-shape, but the tool name and description together are sufficiently specific.

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, no input prerequisites, and no exclusions. 'Check a Jira issue key shape' is a statement of purpose rather than usage 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 must carry the behavioral burden; 'Body discarded' is a useful, non-obvious disclosure that only the status is meaningful, and 'HTTP status' clarifies the output. But it does not address error behavior, how status is determined, whether network access is used, or what happens when different or multiple params are supplied.

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 terse sentences with no filler; the most important behavioral caveat ('Body discarded') is stated immediately, and 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?

The combination of nine optional parameters, no annotations, and no output schema needs more than a one-line description. An agent cannot tell how to invoke the library-docs-URL use case, what the returned status looks like, or why the schema includes city/feed/json/zone/query parameters; the per-parameter schema descriptions do not connect these to the tool's stated 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 coverage is 100%, so the baseline is 3; the schema already describes each parameter. The tool description adds almost nothing about parameter semantics beyond implying the 'url' field is the relevant one, and with nine optional parameters it does not clarify whether they are alternatives, combinations, or unrelated.

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 concrete output ('HTTP status') and a specific resource ('public library docs URL'), and it adds a meaningful behavioral note ('Body discarded'), so the basic operation is understandable. It does not name or differentiate against close siblings such as fetch-status or browser-url-ok, so it misses the top score; the broad nine-parameter schema also muddies which input is actually relevant.

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

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

There is no when-to-use guidance, no mention of alternatives, and no exclusion such as 'for general URLs use fetch-status instead.' The only inference is from the narrow phrasing 'public library docs URL,' which is not enough to route an agent reliably among the sibling tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does disclose that values are discarded, which is useful, but it omits the return format, behavior on invalid JSON, side effects, and whether any values are persisted or accessed.

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 operation is front-loaded and the important caveat 'Values discarded' follows immediately. The structure is exemplary, even though the content is thin.

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

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

With 9 optional parameters, no required fields, no annotations, and no output schema, the agent cannot determine which arguments are relevant or what the return value will be. The sparse description is inadequate for confident invocation beyond guessing at the `json` parameter.

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 plausibly maps to the `json` parameter, the only JSON-related field, but it never explicitly says to populate that parameter, and the schema description for `json` focuses on validation, not counting keys, creating ambiguity across the 9 optional parameters.

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

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

The description states a specific verb and resource: count keys in a JSON object. The additional phrase 'Values discarded' clarifies a key behavioral qualifier and distinguishes it from validation or shape-checking tools. It is clear about the core operation, though it does not name which input parameter carries the JSON object.

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 like validate-json, domain-shape, or jira-key-shape. The description implies counting keys, but it never states explicit conditions for use or mentions alternatives.

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

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

No annotations are provided, so the description carries the behavioral burden. It clearly discloses that query and fragment are dropped and that origin, host, and path are returned. This is meaningful behavioral context, though it does not describe edge cases or validation 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?

Two short sentences with no wasted words. The main output is stated first, and the exclusion behavior is front-loaded in the second sentence.

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

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

The description is adequate for a simple read-only normalization tool: it states return values and dropped components. However, it does not clarify that only 'url' is the meaningful input, does not explain what happens with the other input fields, and does not specify behavior on invalid URLs, leaving some gaps given the seven-parameter schema and no output 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 descriptions cover all seven parameters, so the baseline is 3. The description adds useful context about 'origin' and query/fragment removal, but it also introduces ambiguity by naming 'host' and 'path' as outputs while those same names appear as input parameters.

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

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

States a specific verb ('Return') and resource ('origin, host, and path for a URL'), and adds the key behavior of dropping query and fragment. This clearly distinguishes it from sibling URL-checking and fetching tools like browser-url-ok or web-fetch.

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 caller needs normalized URL components with query/fragment removed. However, it does not explicitly state alternatives or exclusions relative to sibling tools, so the guidance is implicit rather than explicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'No browser is launched' is a useful behavioral hint, but the description does not disclose whether a network request is made, what 'can be opened' means, what side effects or permissions are involved, or what the tool returns.

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: two short sentences, front-loaded with the main action and followed by a meaningful clarifier. No filler is present, though the brevity does leave important context uncovered.

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 annotations and no output schema, so the description needs to do substantial work. It only explains a narrow URL-checking behavior, ignoring the broader parameter set and failing to specify what outcome the agent should expect or when this tool is appropriate relative to 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 description coverage is 100%, so the baseline is 3. The description itself adds no parameter-level meaning; the schema already documents each parameter in detail. The description's focus on URLs is only loosely connected to the many non-URL parameters in the schema, but the schema mitigates 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 a specific verb and resource: 'Check whether a URL can be opened.' The added 'No browser is launched' gives a useful clarification. However, it does not differentiate this tool from sibling tools like browser-url-ok or fetch-status, and the schema's many non-URL parameters make the scope less certain.

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, web-fetch, or normalize-url. It does not mention exclusions, prerequisites, or conditions that would route an agent to a sibling tool.

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

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

The description discloses that the query is discarded, which is a useful privacy-related behavior. However, there are no annotations to rely on, and the description does not mention the output format, whether it ignores other parameters, or any other side effects. This leaves significant behavioral uncertainty.

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

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

The description is extremely concise at two sentences, front-loading the core action and adding a meaningful privacy note. Every word earns its place, and there is no redundancy. However, it is so brief that it sacrifices necessary operational 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 a large, seemingly unrelated input schema and no output schema, the description is far from complete. It fails to explain how to invoke the tool correctly, which parameter to use, what the return value looks like, or how the schema properties relate to the purpose. The privacy note is insufficient to compensate for these gaps.

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

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

The input schema lists seven string properties (ref, url, city, feed, host, json, path) with individual descriptions, but none of them clearly represents a 'search query.' The tool description never maps its stated purpose to any parameter, so an agent cannot determine which input to provide. The schema descriptions are detailed but irrelevant to the tool's actual function, making parameter semantics critically deficient.

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: count characters in a search query. It uses a specific verb and resource, and the tool name reinforces this purpose. However, it does not differentiate from sibling tools or clarify what constitutes a search query in the context of the provided schema.

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

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

There is no guidance on when to use this tool versus alternatives, no mention of context or constraints, and no exclusion criteria. The description simply states what the tool does without any usage 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 provided, the description carries the full burden of behavioral disclosure. 'Short catalog' implies a read-only result, but it does not mention side effects, output format, pagination, or that input parameters appear to be discarded. The schema's 'discarded' qualifiers are not reconciled with the catalog behavior.

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

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

The description is a single, short sentence with no filler words and is easy to scan. However, the brevity comes at the cost of missing operational context, so it earns a high, but not top, 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 tool with seven parameters and no output schema or annotations, a one-phrase description is materially incomplete. An agent cannot determine the return format, whether any parameter is required, what 'common' means, or how the conflicting 'discarded' parameter descriptions relate to the catalog.

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 description does not explain any of the seven parameters or how they relate to the HTTP status catalog. Although each parameter has a schema description, those descriptions seem unrelated to a catalog (e.g., 'City name for a public weather hint; discarded after the call') and do not clarify whether or why the parameters affect the output.

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

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

The description names a specific resource ('common HTTP status codes') and indicates a catalog, so an agent can generally infer what the tool is about. However, it lacks an explicit verb, uses a noun phrase rather than an actionable statement, and does not differentiate itself from siblings like fetch-status or browser-url-ok.

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

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

There is no guidance about when to use this tool, when not to use it, or how it compares to sibling tools. The description says nothing about input requirements, optionality, or contexts where a more specific tool would be better suited.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It does disclose that the prompt is discarded, which is useful, but it does not explain what happens with the seven input schema fields, whether any of them affect the output, or what the returned template contains. The schema also contradicts this by providing fields that seem intended for validation or use.

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: the first sentence immediately states the function, and the second adds a useful behavioral note. It is concise, though slightly too terse to fully support the agent in using the tool correctly.

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 that there are seven input parameters and no output schema, the description is incomplete. It does not say which parameters are required, how they relate to the template, what the template looks like, or what happens when invalid inputs are provided. The agent is left to infer too much from a schema that appears unrelated to the described behavior.

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

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

The input schema already gives each parameter a description, many explicitly noting that the value is discarded after a shape check, so schema coverage is high. The tool description itself adds no parameter information, but because the schema carries the semantic detail, a 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 clearly states that the tool returns a three-step thinking template, which is a specific verb plus a concrete output resource. It is not a tautology, but it does not explain what the input parameters are for or how the template is constructed, so it stops short of a perfect 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 alternative tools, and none of the sibling tools are referenced. The phrase 'Prompt discarded' hints that this is a template generator rather than an analysis tool, but that is not enough to help an agent decide when to invoke it.

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

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

With no annotations, the description carries the full burden. It implies a read-only operation but does not explicitly state side effects, error behavior for invalid timezone names, or return format. Minimal transparency, though the read-only nature is reasonably inferable.

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 that front-loads the resource and operation. It contains no filler or redundancy.

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

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

The tool is simple, but the definition is incomplete because the schema does not contain a timezone parameter, and the description does not map the concept to any schema field. No output schema or alternative routing information is provided, so an agent cannot successfully invoke 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?

The description mentions a 'named IANA timezone,' but none of the seven input schema parameters (ref, url, city, feed, host, json, path) represent a timezone. Their descriptions, like 'Git ref name; discarded after the shape check,' are unrelated to the tool's purpose. Even though schema coverage is 100%, the parameter descriptions fail to connect to the described functionality, making it impossible to know which parameter to set.

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 time in a named IANA timezone' clearly states the operation (get current time) and the resource (IANA timezone). It implicitly distinguishes from siblings like utc-time and iana-zones by specifying a named zone rather than UTC or a zone list.

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 on when to use this tool versus alternatives such as utc-time or iana-zones. There are no explicit exclusions or context clues beyond the basic purpose, leaving the agent to infer usage without support.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only says 'Current UTC timestamp.' It does not specify the timestamp format, how the nine schema parameters relate to the call, or whether any side effects are involved.

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

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

The description is extremely concise and front-loaded, with no wasted words. It is slightly under-specified as a noun phrase rather than a full instruction, but it is appropriately sized for a simple time-returning 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?

Without an output schema, the description should explain the return value format, but it only says 'timestamp.' With 9 optional parameters and no annotations, the description is too incomplete to fully guide an agent on how 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?

Schema description coverage is 100%, so the schema already documents every parameter, including notes that several are discarded or checked without disk access. The tool description itself adds no parameter meaning, which fits 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 states the tool's output: a current UTC timestamp. It is clear about the resource but lacks a verb and does not differentiate from sibling tools like timezone or iana-zones.

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

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

There is no guidance on when to use this tool versus alternatives such as timezone, nor any mention of when not to use it. The implied context is 'need current UTC time,' but no exclusions or alternative routing are provided.

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

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

With no annotations, the description must disclose behavioral traits. It states that 'the body is discarded', which communicates a non-retention behavior. However, it does not clarify side-effects (e.g., network calls), error handling for invalid JSON, or read-only status, and the term 'body' is not mapped to the schema's parameters.

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

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

The description is concise with only two sentences and the main purpose is front-loaded. However, the second sentence adds marginal value beyond the schema's parameter descriptions, and the undefined 'body' term creates ambiguity that detracts from the clarity achieved by brevity.

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

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

For a tool with 8 parameters, no output schema, and no annotations, the description is under-specified. It does not explain which parameter holds the JSON to validate, what the tool returns (e.g., boolean, error), or how the other parameters relate to the validation, leaving an agent without enough context to invoke it correctly.

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

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

The input schema covers all 8 parameters with descriptions, so the schema already carries full parameter semantics. The description adds no new parameter-specific meaning; 'body' is not tied to any schema property, and the 'discarded' note mostly duplicates existing schema text.

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 ('check') and a resource ('a body') with a clear success criterion ('valid JSON'). It differentiates from sibling shape validators (e.g., domain-shape, wiki-title-ok) by focusing on JSON content, though it does not name a sibling explicitly.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention any sibling tools, preconditions, or selection criteria, leaving the agent to infer usage solely from the tool 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the external data source (Open-Meteo) but does not state whether the operation is read-only, what happens to the input, or any rate limits or side effects. The schema's mention that the city is 'discarded after the call' is 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, focused sentence with no filler words. The core purpose is front-loaded, and the mention of the data source is succinct. It is an appropriately sized definition for a simple hint 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?

The description tells the agent what the tool returns, but the input schema contains six unrelated parameters with no explanation of why they exist or whether they are ignored. Without an output schema or annotations, the description leaves ambiguity about which parameter to pass and how the tool handles the others. This is a clear gap in completeness.

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 high (every property has a description), so the baseline is 3. The tool description itself does not mention parameters or clarify which of the seven schema properties are relevant. However, the phrase 'for a city' aligns with the 'city' property description, and the schema provides definitions for all parameters.

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

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

The description clearly identifies the resource and purpose: it returns the current temperature for a city using Open-Meteo. The weather-specific wording distinguishes it from sibling tools like geo-hint. It lacks an explicit verb such as 'Get' or 'Return', so it stops just short of a perfect 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?

The intended usage is implied by the description: use this tool when you need a city's current temperature. However, there is no explicit guidance about when not to use it, nor any mention of alternative tools for similar tasks. The usage is clear but not articulated beyond the purpose itself.

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 explicitly states that the body is discarded, which is a key behavior, and notes it is for public URLs. However, it omits other behavioral details such as redirects, timeouts, or how the many non-URL parameters are handled, leaving significant 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 a single concise sentence that front-loads the core purpose and a key behavioral detail ('Body discarded'). There is no extraneous content, making it efficient and easy to parse.

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

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

Given the tool has nine parameters and no output schema, the description is notably incomplete. It only mentions the URL and status/content type, omitting the return format, error handling, and the purpose of the other eight parameters. The agent would have to rely heavily on the schema and context to use 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?

Schema description coverage is 100%, with each parameter having a detailed description, so the baseline is 3. The tool description adds no value beyond the schema and actually creates confusion by implying only a URL is relevant while nine parameters exist. The schema descriptions themselves clarify each parameter's role, but the description does not tie them together or explain the overall parameter usage.

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

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

The description states a specific verb ('fetch') and resource ('HTTP status and content type') for a public URL, making the core purpose clear. However, it does not differentiate from sibling tools like fetch-status or browser-url-ok, which likely serve similar purposes.

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. It does not mention any conditions, exclusions, or alternatives, leaving the agent to infer usage from the name and description alone.

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

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

The description does add one behavioral trait: the title is discarded after the call, implying a stateless, non-retaining operation. However, with no annotations present, it does not disclose return behavior, error cases, network effects, or rate limits, leaving part of the safety burden unmet.

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 and front-loads the core purpose. The second sentence is brief, though its value is limited because 'title' does not correspond to a schema property and the discarding behavior is already echoed in the parameter descriptions.

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 are no annotations and no output schema, and the description omits return type, required inputs, and concrete example values. Combined with the mismatch between the stated 'title' and the actual schema properties, the definition is not sufficient for an agent to call 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 string properties with individual descriptions, but none of them is a Wikipedia title; they describe Git refs, URLs, cities, feeds, hosts, JSON, and paths. The description's mention of a title cannot be mapped to any parameter, which is worse than silence: an agent cannot determine how to invoke 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 first sentence names the action (check existence) and resource (Wikipedia title), distinguishing it from siblings like browser-url-ok or file-path-ok. It loses a point because the description never maps 'Wikipedia title' to any actual input property, so the stated purpose is not actionable without guessing.

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 conditions, prerequisites, or when-not-to-use guidance. It does not mention alternatives such as normalize-url, web-fetch, or citation, so an agent has no basis for choosing this tool over related ones.

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