Pacific/Kiritimati clock

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

Annotations already mark this as read-only, idempotent, and safe. The description adds meaningful behavioral detail by stating that 'Task text discarded' and by enumerating the returned artifacts: CLI setup, how-it-works, skill file, and remote MCP hops. This exceeds what annotations alone tell the agent.

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

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

Two sentences, no filler: the first sentence identifies the target, and the second specifies both outputs and a notable side-effect (task text discarded). The key information is front-loaded and every sentence earns its place.

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

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

Since there is no output schema, the description compensates by naming all four artifact types returned. With full parameter documentation and read-only annotations, this is sufficient for an agent to understand what the call does and what it receives.

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 property descriptions cover 100% of the seven parameters, so the description does not need to duplicate their meanings. It adds no per-parameter detail beyond the schema, which fits the baseline 3 for full schema coverage.

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

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

The description uses a specific verb ('Find') on a specific resource ('public pay-per-call tool gateway (Monid)') and lists the exact outputs. This clearly distinguishes it from sibling tools like lib-docs-hint or status-catalog, which point at different resources.

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 clear context: use this tool when you need a Monid pay-per-call gateway and its CLI/skill/hops details. It does not explicitly name alternatives or exclusion conditions, but no sibling appears to overlap with this purpose directly.

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 transparency burden. It does disclose a key trait—no browser is launched—but it does not explain whether a network request is made, what 'can be opened' means (syntax vs. reachability), or what happens with the extra schema 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?

Two short, front-loaded sentences with no filler. The core purpose is stated immediately, and the behavioral caveat follows directly.

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

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

Given seven schema parameters, no output schema, and no annotations, the description is too thin. It does not specify the return value, the method of checking, or how the non-URL parameters relate to the tool, leaving an agent with significant ambiguity about 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 provides descriptions for all parameters (100% schema_description_coverage), so the baseline is 3. The description adds no parameter-level detail beyond aligning 'a URL' with the 'url' property, and it does not clarify the role of the other six 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 concrete action and resource: 'Check whether a URL can be opened.' It differentiates itself from sibling tools like playwright-url-ok by adding 'No browser is launched,' though it doesn't explicitly name the alternatives.

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

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

No explicit when-to-use or when-not-to-use guidance is provided. The second sentence is a behavioral constraint, not a usage directive, leaving the agent to infer how this tool compares to normalize-url, 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?

With no annotations provided, the description bears the full burden of behavioral disclosure. It only hints at statelessness with 'Expression discarded,' but does not disclose the return format, error behavior, side effects, or whether any actual computation 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 very short and front-loaded, which is good. However, the second sentence adds ambiguity rather than clarity, and the overall terseness omits necessary context, so it is not an effective concise 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?

The definition is not complete enough for an agent to call correctly: there is no output schema, no mention of a return value, no required parameter, and a mismatch between the described expression input and the actual schema. The agent would be left guessing what to pass and what 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 schema properties all have their own descriptions, but the tool description never connects its stated 'expression' input to any of the seven properties. An agent cannot tell which parameter carries the arithmetic expression, and none of ref, url, city, feed, host, json, or path semantically represents an expression.

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

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

The description states a specific action: evaluate a+b style arithmetic. However, the phrase 'Expression discarded' creates ambiguity about whether the tool computes a result or only checks/discards the input, and the input schema contains no obvious 'expression' parameter to match the stated purpose.

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

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

No guidance is given about when to use this tool rather than related siblings such as validate-json, domain-shape, or other shape-check tools. There are no conditions, exclusions, or alternative tool references to help an agent select it appropriately.

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

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

Annotations already establish read-only, safe, and idempotent behavior. The description adds a useful behavioral trait beyond those: 'Page content is not stored,' which clarifies privacy/storage semantics. It does not contradict the annotations and provides context about what the tool does not do.

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 primary behavior is front-loaded, and the second sentence adds a meaningful privacy guarantee. Every word earns its place.

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

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

The tool has a complex multi-parameter schema (url, city, json, feed, etc.), yet the description only addresses the URL case. Without an output schema, the agent lacks a complete picture of what the tool returns or how the other parameters behave in context. The description is therefore not complete enough for the tool's 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 the schema coverage is high. The tool description adds no parameter-specific meaning beyond the schema, but the baseline of 3 is appropriate because the schema already carries the explanatory 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 states a specific, concrete behavior: 'Return host, scheme, and HTTP status for a URL.' This distinguishes it from content-fetching tools like web-fetch. However, it mentions only the URL aspect and ignores the other seven input schema parameters (city, feed, json, etc.), so the purpose is only partly captured.

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 choose this tool over siblings such as normalize-url or fetch-status. The statement 'Page content is not stored' weakly implies it is not for content retrieval, but no alternative is named and no explicit when/when-not rules 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?

The description and parameter descriptions explicitly promise privacy via data discarding ('No identifiers are retained', 'discarded after the shape check', 'discarded after the call'), which is a meaningful behavioral guarantee. However, with no annotations available, the description does not disclose whether the tool makes external network requests, what side effects (if any) occur, or what the response contains. Some behavioral context is provided, but significant gaps remain.

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, front-loaded with the core action and followed by a relevant privacy note. There is no verbose filler or repetition. The brevity is efficient, although it borders on under-specification, which prevents a 5.

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

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

The tool accepts eight heterogeneous inputs and has no output schema, yet the description does not explain what the classification result looks like, how the parameters interact, or whether multiple parameters can be combined. An agent has no way to anticipate the return value or decide which parameters to supply. For a tool this complex, the description is critically 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?

The schema descriptions already document each parameter in detail (e.g., 'Git ref name; discarded after the shape check', 'JSON text to validate; discarded after the check'), so schema coverage is high. The tool description itself adds no parameter-level meaning; notably, it does not clarify the ambiguous 'type' parameter beyond its own vague description 'Type of result to return'. With the schema doing the heavy lifting, 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 verb ('Show') and a resource ('this request'), but 'classified' is undefined: there is no explanation of what classification categories exist, what output to expect, or which of the many input fields drive the classification. The name 'compatibility' and the broad set of heterogeneous parameters (ref, url, city, feed, host, json, path, type) suggest a general classification/dispatch tool, but it is not differentiated from siblings like domain-shape or validate-json.

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 or which alternative to prefer. The parameter descriptions hint at different domains, but the main description gives no condition such as 'use when the request type is ambiguous' or 'use to check which format applies.' An agent is left to infer the intended trigger.

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 full responsibility for behavioral disclosure. It reveals that the tool only produces labels and excludes ownership data, but it doesn't mention side effects, network usage, or output format. This provides some but not rich behavioral 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?

One sentence, zero redundancy, and the core action is front-loaded. Every word contributes to defining the purpose and a key constraint, making it highly efficient.

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

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

The description is adequate for a simple tool but incomplete given the large schema. It does not specify which parameter to use (e.g., 'host') or describe the return structure beyond 'labels' – especially problematic since there is no output schema. An agent might struggle to assemble the correct call among the many unrelated 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 input schema already describes all parameters at 100% coverage, so the baseline is 3. The description adds no additional parameter meaning beyond aligning loosely with the 'host' parameter; it does not clarify how the many other schema fields relate to the tool's operation.

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

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

The description uses a specific verb ('Split') with a clear resource ('a hostname') and a distinct non-goal ('without WHOIS or ownership data'). This precisely distinguishes it from sibling 'shape' tools like github-repo-shape or figma-url-shape, making the tool's purpose immediately identifiable.

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 (whenever a hostname needs splitting) and hints at an exclusion (no WHOIS/ownership), but it does not explicitly mention alternative tools or conditions for choosing between them. Usage context is inferable, not stated.

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

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

The description discloses the HTTP method (HEAD), target type (public URL), and output restriction (status only), which is useful. But with no annotations, the description carries the full burden, and it still leaves unexplained how the many non-URL parameters are treated, whether side effects occur, and what the returned status looks like; schema notes like 'discarded after the call' also conflict with the HEAD-URL framing.

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, which is good. But it is under-specified relative to the schema's complexity; brevity comes at the cost of leaving essential invocation context 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?

With seven parameters, no output schema, no annotations, and overlapping sibling tools, a one-line description is far from complete. An agent still cannot tell what input to supply, what the status response contains, or how this tool differs from the surrounding URL-checking and validation 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?

All seven parameters already have explicit schema descriptions (100% coverage), so the description does not need to restate them. It adds the HEAD/public-URL/status-only semantic for url but does nothing to reconcile why json, city, path, ref, feed, and host are accepted or which parameter is actually required.

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

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

The phrase 'HEAD a public URL and return status only' identifies a concrete verb, resource, and outcome, so it is not a tautology. However, the input schema exposes seven heterogeneous parameters (ref, city, json, path, host, feed) described as shape checks, validations, or discarded values, so the description captures only a narrow slice and is misleading about what this tool actually accepts or does.

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 if/when-not guidance or alternative tools are mentioned. Siblings such as browser-url-ok, playwright-url-ok, web-fetch, and normalize-url all overlap with URL checking/fetching, and this definition gives an agent no basis for choosing fetch-status over them. The only weak signal is the implied 'status-only HEAD' use case.

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 at all, the description carries the full disclosure burden and offers only one behavioral trait ('Path discarded.'), which is itself ambiguous between the URL's path and the 'path' parameter. The description conflicts with the schema: it says 'Figma file URL' while the url parameter is generically described as 'HTTPS URL to normalize or cite', and 8 unrelated parameters (city, feed, json, zone, query...) appear without explanation. It never states the return value or that this is a local shape check.

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

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

The two short sentences are front-loaded and free of padding, but this is under-specification, not coniseness: for a 9-param tool with no annotations and no output schema, 8 words cannot cover the ground. The cryptic fragment 'Path discarded.' raises ambiguity rather than resolving it, so neither sentence fully earns its place.

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

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

Given 9 parameters, zero required, no annotations, no output schema, and a 26-tool sibling list full of URL and shape tools, the description is severely inadequate. An agent cannot determine what a valid Figma file URL looks like, what the tool returns, how it differs from normalize-url or browser-url-ok, or which parameters apply to the 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?

Despite 100% schema description coverage (baseline 3), the description actively misaligns with the schema: it names a Figma-file URL use case while the url parameter is described generically, and no parameter is identified as the one to pass for that use case. With all 9 parameters optional and no required ones, the description offers zero help in choosing among city, feed, json, zone, query, and the rest.

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 verb and resource ('Parse a Figma file URL'), which goes beyond a pure tautology of the tool name, but 'parse' is ambiguous — it doesn't say whether the tool validates URL shape, extracts components, or normalizes. 'Path discarded' raises questions (which path? discarded from what?) rather than clarifying scope, and no differentiation from sibling *-shape tools is offered.

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 any of its 26 siblings, particularly the closely related normalize-url, browser-url-ok, and github-repo-shape. There is also no indication of which of the 9 optional parameters (all unrequired) an agent should supply for a Figma-file-url 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?

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose 'No disk access,' which is valuable, but it does not explain whether the tool is purely syntactic, what 'safe' means, what side effects it has, or what output to expect. The behavioral picture is incomplete.

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

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

The description is short, front-loaded, and contains no filler; both sentences contribute useful information. However, it is slightly undersized given the complexity of the schema and the need to resolve ambiguity about which parameters actually apply.

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

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

The tool has a seven-parameter schema and no output schema, but the description only addresses one concept ('path') and does not explain return values, which parameters are valid together, or how this tool relates to the sibling shape-checking tools. An agent would likely struggle to invoke it correctly without additional 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?

The input schema already provides descriptions for every parameter, so schema coverage is high and the baseline is 3. The tool description adds no parameter-level meaning and fails to clarify why the schema includes many unrelated fields ('url', 'city', 'json', etc.) when the description focuses only on 'path'.

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

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

The description states a clear action and object: 'Check whether a path looks safe.' It also adds a meaningful scope qualifier, 'No disk access,' which distinguishes it from tools that actually access the filesystem. It does not name sibling alternatives, but the resource and verb are specific enough for basic selection.

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 safe, static, non-disk-touching check, but it gives no explicit guidance about when to use this tool versus the many sibling shape-checking and URL-checking tools. No when-not-to-use conditions or alternative tool names are provided.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It does not mention side effects, return format, rate limits, or what happens when multiple parameters are provided. The schema property descriptions mention values being 'discarded', but the tool description itself offers no such transparency.

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

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

The description is a single short sentence, which is concise, but it is under-specified rather than efficiently communicative. It omits critical information and would need substantial expansion 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?

With a complex schema containing seven parameters, no output schema, and no annotations, this description is entirely inadequate. An agent cannot infer the tool's behavior, expected inputs, or return values from the text provided.

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 descriptive text for every parameter, so coverage is high, giving a baseline of 3. The tool description adds no parameter-level meaning beyond the single 'city' reference, but the schema descriptions do 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 result ('Latitude and longitude for a place via Open-Meteo'), but it is a noun phrase with no verb and does not explain why the input schema includes seven unrelated fields (ref, url, feed, json, path, host). This makes the tool's actual purpose ambiguous and potentially misleading to an agent.

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 instead of siblings like weather-hint, timezone, or domain-shape. The description provides no context for selection.

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, and the description does not state whether the tool is read-only, what side effects it has, or how it behaves on invalid input. The 'discarded' notes on some params hint at non-persistence but do not clarify tool 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 focused sentence with no filler. Parameter descriptions are also short and do not waste words.

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

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

There is no output schema, no required parameters, and no mention of which of the nine optional params actually matter. The description does not explain return shape, failure behavior, or the role of the many unrelated params, leaving the tool's usage context incomplete.

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

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

All nine parameters have descriptions, so schema coverage is high, but most are unrelated to parsing a GitHub repo (city, feed, zone, query). The url description says 'normalize or cite' rather than 'parse owner and repo,' which dilutes and mildly conflicts with the tool's stated purpose.

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

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

The description is a specific verb-plus-resource statement: 'Parse owner and repo from a GitHub URL.' It clearly distinguishes this from sibling shape tools like 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?

There is no guidance on when to use this tool versus normalize-url, domain-shape, or the other sibling tools. The description gives no alternatives or exclusions, so the agent receives no 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 carries the behavioral disclosure burden. It does disclose a key limitation ('Titles discarded') and implies a read-only counting operation. However, it does not explain whether external fetches occur, what the output format is, or why all nine parameters are accepted, leaving several behavioral aspects opaque.

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

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

The description is two short sentences with no filler. The primary action 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?

The description identifies the tool's core purpose but does not clarify how the nine optional, seemingly unrelated parameters relate to the operation. There is no output schema, no annotation coverage, and no statement that the parameters are discarded, so an agent cannot confidently determine which arguments, if any, should be supplied. This is a meaningful gap for a tool with this much schema surface area.

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

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

The input schema has 100% description coverage, so the baseline is 3 even though the tool description itself explains no parameters. The only relevant parameter clarification, 'Titles discarded,' is also present in the feed parameter description. The description therefore adds little beyond 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 clear, specific action: 'Count current Hacker News front-page stories.' It also adds an important scoping detail with 'Titles discarded,' so an agent immediately knows the output is a count rather than story content. This is sufficiently distinct from the listed 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 when to use this tool: whenever the current number of Hacker News front-page stories is needed. 'Titles discarded' hints that it should not be used when titles are required, but the description does not name alternatives or provide explicit when-not-to-use guidance.

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

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

There are no annotations provided, so the description carries the full burden of behavioral disclosure. The description only mentions 'IANA timezone names' and 'clock calls', but does not explain what happens when the tool is called, what it returns, or how it processes the varied input parameters like 'ref' and 'json'. The schema descriptions mention discarding values after a shape check, but the tool description itself is silent on any 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 brevity is not an advantage here. The single sentence is a vague fragment that does not earn its place because it communicates no actionable information about the tool's operation. It lacks structure such as a clear action, scope, or conditions.

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

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

Given a complex input schema with seven heterogeneous parameters and no annotations or output schema, this description is grossly inadequate. It does not explain what the tool does with these parameters, what it validates, or what the expected input/output format is. An agent cannot reliably invoke this 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?

The input schema descriptions cover all parameters, so the baseline is 3, but the tool description actively detracts from parameter understanding by implying a timezone-related purpose that does not match the schema. The described 'timezone names' do not map to any of the seven parameters, and the description adds no insight into how parameters like 'feed' or 'path' relate to timezone zones. This is more likely to confuse than help an agent.

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 defines what the tool is, not what it does. It lacks a verb indicating an action, and it conflicts with the input schema, which contains parameters like 'url', 'host', and 'json' rather than any timezone field. This makes the tool's actual function unclear and potentially misleading.

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 or compare against sibling tools such as 'timezone' or 'utc-time', nor does it describe any conditions for invocation. An agent has no basis for selecting this 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 present, the description carries the full burden of behavioral disclosure. It does mention that the tool fetches a public robots.txt and only returns group counts, but it does not disclose parsing failure behavior, required parameter usage, potential redirects, rate limits, or side effects. Several schema parameters are described as 'discarded,' but the description itself never warns about this.

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, tightly written sentence with no filler. The core action and output constraint are both front-loaded, making it very easy to scan.

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 seven-parameter schema, the absence of annotations, and no output schema, the description is not complete enough for reliable tool selection. The agent still cannot confidently determine which parameter identifies the robots.txt URL or host, and no failure or edge-case context is provided.

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

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

Although every parameter has a schema description, those descriptions do not align with the stated tool purpose: none of them mentions robots.txt, and 'url' is described as a URL 'to normalize or cite' rather than the source for the robots.txt fetch. The description does not bridge this gap, leaving the agent unsure which parameter to supply for the core operation.

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 ('Fetch') with a clear resource ('public robots.txt') and a precise output constraint ('return group counts only'). It is distinguishable from generic fetch tools, but it does not explicitly contrast with sibling tools such as web-fetch or domain-shape.

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

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

The description gives no guidance on when to choose this tool over alternatives, nor does it mention any exclusions, prerequisites, or preferred input selection. The word 'public' weakly implies unauthenticated use, but the description does not state when to use this tool versus related ones.

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

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

No annotations are present, so the description must carry the behavioral burden. It does disclose that the key is discarded, implying no persistence, and 'check' suggests non-mutating validation. However, it does not explain whether any network call is made, what the tool returns, or how errors surface, leaving a partial but incomplete picture.

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 terse and front-loaded: it states the purpose first, then adds a short retention note. Every sentence carries some information and there is no filler. It is concise, though the minimalism contributes to gaps 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?

With no output schema and no annotations, the description needed to explain the return contract, the input-to-key mapping, and what 'shape' means. It does none of these. The seven heterogeneous parameters and the lack of a named Jira-key parameter leave the tool substantially under-specified.

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

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

The input schema has seven properties, each with its own description, so schema-level coverage is high. Yet none of the properties is labeled as the Jira key, and descriptions like 'Git ref name', 'HTTPS URL', and 'City name' do not map clearly to a Jira issue key. The description provides no guidance on which parameter to populate, undercutting the baseline score.

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 a specific action and resource: 'Check a Jira issue key shape.' It is not a tautology and loosely distinguishes from sibling shape tools. However, 'shape' is undefined, and the second sentence 'Key discarded' is about data handling rather than purpose, adding a slight ambiguity.

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

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

No guidance is given about when to use this tool versus alternatives like github-repo-shape, domain-shape, or validate-json. There is no mention of context, exclusions, or conditions. 'Key discarded' hints at safe handling but not at usage selection.

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

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

No annotations are present, so the description must fully disclose behavior. It does say 'Body discarded', which is a useful detail, but it fails to clarify that the schema accepts a wide variety of unrelated input shapes, whether the status check is live or simulated, rate limits, or error handling. The 'public library docs URL' wording is inconsistent with the general-purpose schema, making actual behavior unclear.

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 the brevity comes at the cost of necessary clarity. It front-loads the core action, yet the second fragment 'Body discarded' is the only behavioral note and is placed without context. This reads as under-specification rather than effective conciseness.

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

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

With seven heterogeneous parameters, no annotations, and no output schema, the description must carry substantial explanatory weight. It omits parameter semantics, the exact form of the HTTP status return, and how to select the right parameter. An agent would be hard-pressed to call this tool correctly based on the description alone.

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

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

All seven parameters already have individual descriptions in the schema, so the high-coverage baseline applies. However, the tool description adds no parameter-level guidance and may confuse agents by referring to 'public library docs URL' while the url parameter is described as 'HTTPS URL to normalize or cite'. There is also no indication of whether parameters are alternatives or mutually exclusive.

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 — returning HTTP status for a public library docs URL — and notes the body is discarded. However, the schema exposes seven unrelated parameters (city, feed, host, json, path) that this description does not account for, and the 'public library docs' qualifier is not reflected in any parameter. It also does not distinguish this tool from sibling fetch-status, which likely performs the same core check.

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 siblings like fetch-status, web-fetch, or normalize-url. There are no conditions, alternatives, or exclusions mentioned, leaving an agent to infer the appropriate context on its own.

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 disclose that values are discarded, but it does not explain whether the count is top-level only, how invalid JSON is handled, what the return value looks like, or whether there are side effects. This is a meaningful 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 concise and front-loaded with no wasted words. The second sentence 'Values discarded' adds useful behavioral scope. However, it is so terse that it omits necessary context, though that is more a completeness issue than a conciseness one.

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

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

Given no output schema, no annotations, and nine optional parameters, the description is severely incomplete. It does not state the return value, which parameter to supply, recursion behavior, invalid-input handling, or how it relates to sibling tools. An agent cannot reliably invoke this tool correctly from the provided definition.

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 does not connect any parameter to the JSON object whose keys are counted. The closest candidate, 'json', is described as 'JSON text to validate', not as a source for key counting. All nine parameters are optional, and the description adds no guidance on which one matters.

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

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

The description states a specific action and resource: 'Count keys in a JSON object.' The added 'Values discarded' clarifies the scope. It does not explicitly differentiate from sibling tools like validate-json, but the verb and object are clear enough for an agent to understand 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?

There is no guidance on when to use this tool versus alternatives such as validate-json or other shape-checking siblings. 'Values discarded' hints at a narrow use case, but no exclusions, prerequisites, or alternative selection cues 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?

It discloses that query and fragment are dropped and that the result includes origin, host, and path. However, with no annotations, it does not mention whether any network access occurs, error behavior for invalid URLs, or 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 a single concise sentence with no filler. It conveys the core behavior and output in a compact form.

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

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

With no output schema and no annotations, the response shape is unspecified. The presence of many unrelated-looking parameters and the 'query' ambiguity make the description insufficient for confident correct use in all cases.

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

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

Although all parameters have schema descriptions, the tool description does not clarify that only the 'url' parameter is used or how the other discarded parameters relate. The word 'query' in the description also creates ambiguity with the separate 'query' input parameter described as search 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 names a specific operation (return origin, host, and path) and a clear resource (a URL), and it states the filtering behavior. It does not explicitly contrast with sibling URL tools, but the 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?

There is no guidance about when to choose this tool over sibling URL-related tools such as browser-url-ok, fetch-status, or web-fetch. The description implies parsing/normalizing, but does not state exclusions or 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 carries the disclosure burden. It provides one useful behavioral fact: no browser is launched. However, it does not disclose whether a network request is made, what 'can be opened' means in practice, or what the return value looks like, leaving the tool's runtime behavior only partially transparent.

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

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

The description is a single, front-loaded sentence with no filler. 'Check whether a URL can be opened' states the core purpose, and 'No browser is launched' adds essential differentiation in just five words.

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

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

For a simple read-only check tool, the description is largely usable: an agent can infer it takes a URL and returns whether it is openable. But without an output schema or annotations, the exact success criteria and return format are unspecified, and the large set of optional schema parameters is not reconciled with the stated purpose, so the description is not fully complete.

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

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

Schema description coverage is 100%, so each of the nine optional parameters already has an individual description, warranting the baseline score of 3. The tool description adds no per-parameter guidance, but the schema carries the parameter semantics; ambiguity about which parameter to pass for the URL check is mostly resolved by the `url` property and the tool name.

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

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

The description states a clear action and resource: 'Check whether a URL can be opened.' It also adds a distinguishing behavioral detail, 'No browser is launched,' which helps separate it from sibling tools like browser-url-ok. However, 'opened' is somewhat ambiguous—it could mean HTTP reachability, DNS resolution, or renderability—so it is not perfectly explicit.

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-browser note implies this is a lightweight URL check and should not be used when actual browser rendering is required. Still, the description never names alternatives such as browser-url-ok, web-fetch, or fetch-status, and it does not state explicit conditions for when to prefer this tool over them.

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

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

The description does disclose that the query is discarded, which is a useful privacy behavior. However, with no annotations and no further explanation, it fails to disclose what the tool returns, whether there are side effects, or how discarding applies to the many unrelated parameters in the schema.

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

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

The description is short and free of fluff, but it is under-specified rather than efficiently complete. Two sentences are not enough to compensate for the missing linkage between the stated purpose and the actual input schema.

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

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

The tool has no annotations, no output schema, and a large set of parameters that seem unrelated to the description. It does not explain what the returned count looks like, which field carries the query, or why all the schema parameters are present. This is far from complete enough 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?

The schema provides descriptions for every parameter, but none of them is described as a search query; they are all described as discarded or shape-check values. The tool description does not map 'count characters in a search query' to any actual input, so an agent cannot determine what to pass.

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

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

The description names a specific operation, counting characters in a search query, so it is not a tautology. However, the input schema contains no 'query' parameter, and the listed parameters (ref, url, city, feed, json, path, etc.) appear unrelated, making the actual purpose confusing and failing to distinguish the tool from sibling shape/check tools.

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

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

There is no guidance on when to use this tool versus alternatives like memory-key-count, validate-json, or the various '-ok' and '-shape' siblings. No context, exclusions, or selection criteria are provided.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only says 'Short catalog'. It does not disclose that parameters are discarded after shape checks, what the return value looks like, or whether the tool has side effects. The term 'catalog' implies read-only, but the schema hints at validation behavior that the description never acknowledges.

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

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

The description is a single sentence with no filler or redundant phrases. It is front-loaded and easy to parse, though its brevity borders on under-specification for a tool with this many parameters.

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

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

For a tool with seven parameters and no output schema or annotations, a seven-word description is completely inadequate. It does not explain what the tool returns, how the parameters are used, or how it relates to sibling tools. An agent would be unable to invoke this tool correctly without additional 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?

The input schema provides descriptions for all seven parameters with 100% coverage, so the structural data already explains each parameter. The description adds no meaning about how parameters relate to the catalog, 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 'Short catalog of common HTTP status codes' is essentially a restatement of the tool name 'status-catalog' rather than a verb-driven statement of what the tool does. It does not say whether it returns a list, accepts queries, or validates inputs, and the unrelated input parameters (url, city, json, path) create substantial ambiguity about the actual purpose.

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

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

There is no guidance about when to use this tool versus sibling tools such as fetch-status or domain-shape. The description does not provide any context, exclusions, or alternative suggestions, leaving an agent to guess the appropriate invocation context.

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

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

No annotations exist, so the description carries the transparency burden. It openly states that the prompt is discarded and the tool returns only a fixed template; the schema also annotates most parameters as 'discarded after the check/call.' It does not describe the exact template content or any side effects, but for a static, non-destructive template tool this is 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?

Two short sentences; the core instruction is front-loaded and the exclusion 'Prompt discarded' is stated in as few words as possible. No redundant phrases.

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 optional schema and no output schema, the description is thin: it doesn't state that all params are ignored at the tool level or what the three-step template contains. The schema's 'discarded' notes fill part of the gap, but an agent still has to infer that the expected invocation is effectively parameterless.

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 every parameter, so the description needs to add little. It does not explain how the parameters relate to the returned template or whether they are required, but the schema's coverage is high, so 3 is the appropriate baseline.

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

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

States a precise verb+resource: 'Return a three-step thinking template.' The additional sentence 'Prompt discarded' clarifies the tool is not a prompt-processing assistant, distinguishing it from the utility siblings. This leaves no doubt about the core capability.

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?

'Prompt discarded' is a clear negative guideline: the agent should not expect its prompt to influence the result, which tells it when not to rely on this tool for bespoke reasoning. It does not name an alternative tool or a positive condition, so it falls short of a 5.

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

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

No annotations are provided, so the description must carry the behavioral burden. It states the tool returns current time but never explains which parameter supplies the timezone, what the return format is, or what happens with the many 'discarded' inputs. The schema/parameter mismatch makes behavior even more opaque.

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

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

The description is a single short sentence with no filler, which is superficially concise. However, it is too terse for a seven-parameter schema and omits the one piece of information an agent needs: how to supply the timezone. It earns a middle score because it is not verbose but also not appropriately sized for the tool's complexity.

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

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

With no output schema, no annotations, and an input schema full of unrelated parameters, the description leaves almost everything to inference. It does not mention timezone format, return shape, or which parameter to use. An agent cannot reliably determine how to call this 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 schema has seven properties, but none of them represents an IANA timezone, and several are explicitly described as discarded after a shape check. The description adds no meaning for the actual timezone input. This is a critical failure: an agent cannot map the description's 'named IANA timezone' to any parameter.

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

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

The description clearly states what the tool is supposed to do: return the current time for a named IANA timezone. It distinguishes itself from siblings like utc-time and iana-zones. However, the stated purpose is undermined because the input schema contains no timezone 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?

There is no guidance on when to use this tool versus utc-time, iana-zones, or other siblings. The description says only what it does, not when or how to choose it. No exclusions or alternative-tool routes are provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the output and never explains that the nine optional parameters are irrelevant or discarded, nor that no input is required for correct use. The schema hints at discarding for some parameters, but the description itself omits this important behavioral trait.

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

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

The description is a single short phrase with no unnecessary words, and the core output is immediately clear. However, it is a noun phrase rather than a complete usage sentence, and it gives no structural cue about how to handle the many optional parameters.

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

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

For a trivial read-only clock, 'Current UTC timestamp' is nearly enough. However, with nine optional parameters and no output schema, the description should clarify that no parameter affects the result and specify the timestamp format. The schema covers some discarded parameters, but not all, so the description is not fully self-sufficient.

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

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

Schema description coverage is 100%, so the parameters are already documented at the schema level. The description adds no parameter-specific meaning and does not clarify which parameters, if any, affect the result. This meets the baseline for a tool with complete schema coverage but does not exceed it.

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 what the tool returns: the current UTC timestamp. It is resource-specific and easy to understand, but it does not differentiate from sibling tools like `timezone` or `iana-zones`, 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?

The phrase 'Current UTC timestamp' implies the tool should be used when an agent needs the current UTC time, but no explicit when-to-use guidance is provided. Alternatives and exclusions are not mentioned, and the closely related sibling tools would benefit from 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 burden of behavioral disclosure. It does state that the body is discarded, which is useful, but it does not describe what the tool returns for valid versus invalid JSON, whether validation is purely syntactic, or how errors are surfaced.

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

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

The description is two short sentences with no filler. It front-loads the purpose and adds the key side effect immediately, so every word earns its place.

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

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

The tool has nine optional parameters, no output schema, and no annotations, yet the description only says to validate JSON and discard it. It fails to explain how to supply the JSON, what constitutes a successful check, why the other parameters exist, or what the agent should expect as a result.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds no parameter-level meaning and does not explain how the nine optional properties relate to 'body', but each parameter already has its own description in 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 clear action and object: validate whether a body is valid JSON. It is distinguishable at a glance from the sibling format-checking tools, but it does not clarify whether 'body' means the whole request body or the 'json' parameter, which leaves some ambiguity.

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

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

No guidance is given about when to use this tool versus the many sibling validators such as domain-shape, file-path-ok, or wiki-title-ok. The description lacks context, prerequisites, exclusions, or alternative tool routing.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotenceHint=true, so the safety profile is covered. The description adds the external provider (Open-Meteo) and the scope (current temperature), but does not disclose failure modes, units, or external-dependency 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, front-loaded sentence with no filler or repeated information. It is appropriately sized for the tool's apparent simplicity.

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 the description does not specify the return format, units, or which parameter to pass out of the seven in the schema. The annotations cover safety, but the call semantics remain underspecified for an agent.

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

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

With schema_description_coverage low and seven parameters, the description needed to clarify that 'city' is the meaningful parameter, but it only says 'for a city' without naming it or explaining the others. The schema has city-descriptions, but the main description does not compensate for the low coverage or the confusing discarded 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 tool's purpose: returning the current temperature for a city via Open-Meteo. It distinguishes from sibling tools like geo-hint and web-fetch, but it lacks an explicit verb like 'returns' or 'gets'.

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, nor any mention of exclusions or prerequisites. The usage is only implied by the tool name and the word 'weather' in the 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 present, the description carries the behavioral disclosure burden. It responsibly discloses that the body is discarded and that the result is limited to HTTP status and content type, which prevents an agent from expecting response body content. It does not cover redirects, timeouts, or error behavior, but those are less critical for a simple fetch tool.

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

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

The description is two short sentences with no filler. Every word earns its place: 'HTTP status and content type' defines the output, 'public URL' scopes the input, and 'Body discarded' is a critical behavioral note.

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

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

Despite a 9-parameter schema and no output schema, the description only addresses a single URL use case and gives no guidance on how to choose among the many optional parameters. It also does not specify the return format in enough detail or contrast with the similarly named fetch-status sibling. An agent would likely hesitate about which parameters to supply.

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

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

All nine parameters already have detailed descriptions in the input schema, so the baseline is 3. The tool description adds no parameter-level guidance and does not clarify how 'url' relates to the other eight optional fields, some of which look unrelated to fetching. It neither contradicts the schema nor meaningfully enhances it.

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 what the tool produces: HTTP status and content type for a public URL, and explicitly says the body is discarded. It is specific enough to distinguish from unrelated sibling tools like normalize-url or validate-json, though it does not explicitly differentiate itself from the closely named fetch-status sibling.

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

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

The description gives no explicit guidance about when to use this tool versus alternatives. It does not mention fetch-status, browser-url-ok, playwright-url-ok, or any other sibling, nor does it provide exclusions or preferred conditions. The only usage context is weakly implied by 'public 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?

The line 'Title discarded after the call.' does disclose a behavioral trait beyond the annotations, namely that the title input is not retained. Since no annotations are provided, the description carries the burden, but it does not mention whether the tool calls Wikipedia, what it returns, or how failures behave. The disclosure is meaningful but thin.

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

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

The description is two short sentences, front-loaded with the purpose and followed by a disposal note. There is no fluff and each sentence contributes information. The brevity is efficient, though it contributes to a broader under-specification problem captured under 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?

With no output schema and no annotations, the description must explain the input mapping and return behavior itself. It provides neither: the title is implied but absent from the input schema, and the return value is only vaguely implied by 'exists.' This is 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 properties each have descriptions, but none of them is a 'title' and the description never maps 'Wikipedia title' to a specific field. An agent cannot tell whether to pass url, feed, or some other value, or whether the title is expected outside the schema. The disposal statement adds no parameter-binding value.

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

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

The description states a concrete action and resource: 'Check whether a Wikipedia title exists.' This is a specific verb-plus-resource statement, not a tautology, and it helps distinguish the tool from the sibling shape/validation tools. However, it never connects the purpose to any of the seven schema properties, so full clarity is not achieved.

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

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

There is no guidance about when to use this tool versus siblings such as browser-url-ok, normalize-url, or validate-json. The description gives no context, exclusions, or alternative conditions, so the agent receives no routing help.

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