America/Port-au-Prince clock

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

Annotations already mark it readOnly, idempotent, and non-destructive; the description adds valuable behavior beyond that by noting 'Task text discarded' and listing the artifacts returned. The 'public' and 'pay-per-call' phrasing also hints at access/cost characteristics not covered by annotations.

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 efficient sentence that front-loads the primary action and object, then lists the returned contents. It contains no filler and covers the essential behavior without unnecessary detail.

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

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

The description names the return artifacts and key constraint, and the schema covers parameters, so basic calling is feasible. However, it does not explain how to choose among the six heterogeneous parameters, whether any are required, or what exactly 'Task text discarded' means for invocation, and there is no output schema to fill that gap.

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 parameter semantics are already fully provided in the schema. The tool description itself does not add meaning about which parameter to choose or how they relate, but that is acceptable given the schema already documents each field.

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 action and object: 'Find a public pay-per-call tool gateway (Monid)' and lists concrete outputs ('CLI setup, how-it-works, skill file, and remote MCP hops'). This makes the tool's role fairly clear and differentiates it from sibling URL/weather/validation tools, though 'tool gateway' and 'Monid' remain somewhat unexplained.

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

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

There is no explicit guidance on when to use this tool versus alternatives like web-fetch or validate-json, and no preconditions or selection criteria. The only implied usage is 'find Monid', which is essentially a restatement of purpose rather than actionable 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 present, so the description carries the full burden of behavioral disclosure. It discloses one useful trait: no browser is launched. However, it does not explain whether a network request occurs, whether the operation is read-only, what 'opened' means, or what response the agent should expect.

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, purposeful sentences. The main action is front-loaded, and the 'No browser is launched' caveat adds relevant clarification without wasted 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?

Given that the schema includes varied parameters (ref, city, feed, host, json, path) and there is no output schema or annotations, the description is far too thin. It does not explain how these parameters relate to 'checking whether a URL can be opened,' nor what result or side effects are expected.

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 eight parameters, many with clarifying notes like 'discarded after the shape check' or 'discarded after the call,' so schema coverage is high. The tool description adds no parameter-level detail, but the schema carries the load; 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 clear verb and resource: 'Check whether a URL can be opened.' This is more specific than a tautology and immediately signals the tool's primary function. However, it does not explicitly differentiate from siblings like fetch-status or normalize-url, and 'can be opened' leaves the exact criteria (shape check, HTTP reachability, browser compatibility) 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 description gives only the basic intent—checking URL openability—and adds one negative constraint ('No browser is launched'). It provides no guidance on when to prefer this tool over close alternatives such as fetch-status, playwright-url-ok, or normalize-url, and it does not mention any 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?

The description adds only the cryptic note 'Expression discarded.' which vaguely suggests the expression is not stored, but it does not state whether a result is returned, whether the operation is read-only, or any side effects. With no annotations present, the description carries the full burden and falls short.

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 with no filler and the core action is front-loaded. However, 'Expression discarded.' is ambiguous and adds little actionable guidance, so while concise, it is not optimally 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?

For a tool with seven heterogeneous parameters and no output schema, this description is severely incomplete. It fails to specify which parameter holds the expression, what the return value is, and whether the tool is safe to call. The agent cannot reliably invoke this tool from the given text.

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 complete descriptions for all seven parameters, so schema coverage is high. However, the description references 'a+b style arithmetic' and none of the schema parameters accept an arithmetic expression, creating a significant mismatch. The description adds no mapping between the expression and 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 states a specific verb 'Evaluate' and a resource 'a+b style arithmetic', which clearly distinguishes it from sibling tools focused on URLs, files, JSON, or time. The resource is concrete and the intended domain is obvious.

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

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

No guidance is given about when to use this tool versus any alternative. The description does not mention context, prerequisites, or exclusions, leaving the agent without any routing signal among the many sibling validators.

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

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

With no annotations, the description carries the full burden of explaining side effects and guarantees. It does disclose that page content is not stored, which is helpful, but it omits other behavioral details such as error handling, authentication requirements, or rate limits.

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 compact and front-loaded with the primary purpose, and the second sentence adds a meaningful privacy guarantee. It is efficient, though the extreme mismatch between the terse description and the nine optional parameters makes it feel underspecified.

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 complexity of the schema with nine unrelated optional parameters, the description is not complete enough for an agent to invoke the tool correctly. It does not explain the role of most parameters, the expected output format, or how they relate to the stated URL-focused function.

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

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

Although the schema has 100% description coverage, most parameter descriptions are unrelated to the stated purpose of returning host, scheme, and HTTP status for a URL. Params like city, zone, json, and path appear to reference other tools' concerns, and the main description does not clarify how they should be used.

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

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

The description clearly states the core action—return host, scheme, and HTTP status for a URL—and adds a useful limiting detail that page content is not stored. It does not explicitly reconcile this narrow purpose with the tool's name 'citation' or the much broader parameter set, but the primary function is understandable.

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

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

The description gives no explicit guidance on when to prefer this tool over sibling tools such as fetch-status, normalize-url, or web-fetch. It only states a negative behavior ('page content is not stored'), leaving the agent to infer the appropriate 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?

There are no annotations to rely on, so the description carries the full burden. It does add one meaningful behavior—'No identifiers are retained'—which signals privacy/discard behavior. However, it does not disclose side effects, network use, whether it is read-only, or what the classification response contains.

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 compact with no filler; both sentences earn their place, one for purpose and one for data-handling behavior. However, the brevity contributes to ambiguity, so it is strong on conciseness but not flawless.

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 tool with seven heterogeneous inputs, no output schema, and many closely related siblings. The description does not explain what classification is produced, how inputs are used, or what the agent should do with the result. It is not complete enough for correct 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 detailed descriptions for all seven parameters, including discard behavior for several fields, so schema coverage is effectively 100%. The description itself adds no parameter-level information, matching the baseline of 3 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 a concrete action and object: 'Show how this request is classified.' However, it never specifies what classification means, what dimensions are involved, or what output the agent should expect. It is neither tautological nor sibling-differentiating, leaving it vague.

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

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

There is no guidance about when to use this tool instead of any of the many sibling tools like domain-shape, validate-json, or fetch-status. No context, conditions, or exclusions are provided, so an agent cannot decide between this and alternatives.

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

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

With no annotations, the description carries full responsibility. It hints at 'without WHOIS or data' implying no external data fetching, but it does not mention side effects, permissions, or the meaning of the discarded 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 a single sentence and concise, but the wording is awkward and the parameter descriptions (part of the overall structure) are verbose and confusing. The structure of the tool definition as a whole is not clean.

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 does not explain the output format, the relationship between parameters and the operation, or why some parameters are discarded. Given 9 parameters and no output schema, the context is severely 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 parameter descriptions are misleading and inconsistent; e.g., 'ref' says 'Git ref name; discarded after the shape check', suggesting the parameter is not used. None of the 9 parameters are clearly linked to the hostname splitting purpose, and the descriptions do not add meaning beyond the schema type.

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 splits a hostname into labels, which is a specific action and resource. However, the phrase 'without WHOIS or data' is ambiguous and could be interpreted as not fetching external data, but it's not fully clear.

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

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

The description provides no guidance on when to use this tool versus its siblings like normalize-url or browser-url-ok. It does not mention any prerequisites or alternatives.

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

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

With no annotations, the description carries the behavioral burden, and it does useful work by specifying HEAD (no body retrieval), public URLs only, and status-only output. It leaves some details unstated, such as redirects or error behavior, but the safety-relevant read-only nature is clear.

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

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

The description is a single eight-word sentence with no filler. The verb, target, and output are front-loaded and every word contributes meaning.

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 an unusually broad parameter surface (url plus ref, city, feed, host, json, path). The description covers only the url-based HEAD case and leaves unanswered how the other parameters fit, whether any are required, and what 'status' means in the response, so it is not complete enough for reliable invocation.

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

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

The schema already documents all seven parameters with individual descriptions, so the baseline is 3. The description adds the 'HEAD URL' framing that helps identify `url` as the relevant parameter, but it does not clarify how the many 'discarded' parameters relate to the tool's purpose or which ones can be used together.

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

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

The description names a specific HTTP verb (HEAD), a target (public URL), and the outcome (status only), so the core purpose is clear. It does not explicitly contrast with sibling tools like web-fetch or status-catalog, so it stops short of top-tier 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 phrase 'status only' implies a lightweight reachability check where content is not needed, which gives some usage signal. However, the description never states when to prefer this tool over web-fetch, browser-url-ok, or status-catalog, nor does it name 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?

No annotations are present, so the description bears the full disclosure burden. It reveals one useful trait ('Path discarded') but leaves unclear whether the tool is read-only, makes network calls, how it handles malformed URLs, and what it returns. The note is also ambiguous: it could refer to the URL path or the schema's `path` parameter.

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

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

Two short sentences with no filler, and the key constraint is placed first. Still, the second sentence is cryptic enough that a few more words (e.g., 'the URL path component is ignored') would improve clarity without sacrificing 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 no annotations and no output schema, this description must carry more context, but it only covers the input resource and one discard behavior. It omits return semantics, relevant parameters among nine optional fields, and error behavior, leaving the agent under-equipped to invoke it confidently.

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

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

Schema coverage is 100%, so the baseline is 3, and the description does add Figma-specific meaning to the generic `url` parameter. It does not, however, clarify which of the nine optional parameters are relevant or how 'Path discarded' relates to the `path` property, so no bonus above 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 ('Parse') on a specific resource ('Figma file URL'), which helps distinguish it from sibling shape tools like github-repo-shape. However, 'parse' does not specify whether the result is a validation boolean, extracted keys, or a normalized URL, so the purpose is clear but not fully specified.

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 choose this tool over URL-related siblings like normalize-url, browser-url-ok, or web-fetch. The only implied usage is 'when you have a Figma URL,' with no exclusions, prerequisites, or alternative selection criteria.

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

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

Annotations are null, so the description carries the behavioral disclosure burden. It does disclose the important trait that no disk access occurs, which is valuable. However, it does not mention whether the check is purely syntactic, whether inputs are discarded, or what the result/error behavior is.

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, each earning its place: the first states the action, the second states a critical constraint. There is no filler or redundant restatement of the tool name.

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

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

The tool exposes seven heterogeneous parameters and has no output schema, yet the description is only two sentences. It leaves unspecified which parameters are required, what 'looks safe' means, and what response form an agent should 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 description adds little per-parameter meaning, but the input schema already provides descriptions for all seven parameters, including discard behavior for ref, json, and feed. With high schema coverage, a baseline of 3 is appropriate.

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

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

The description states a specific action and resource: 'Check whether a path looks safe,' and immediately clarifies a key boundary with 'No disk access.' It clearly points to file-path validation rather than URL or domain checks, though it does not explicitly differentiate itself 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?

The description gives no guidance on when to use this tool versus alternatives such as browser-url-ok, wiki-title-ok, or domain-shape. It also does not define what 'safe' means or what kinds of paths are valid, leaving the usage decision mostly to inference 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only says Open-Meteo is involved; it does not mention that the call is external, that most schema inputs are discarded, whether anything is persisted, or failure behavior. The schema's 'discarded after...' notes are not reflected in the description.

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

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

The description is a single, front-loaded sentence with no filler, which is positive. But it is under-specified rather than appropriately sized: for a tool with a seven-property schema and no annotations, this level of brevity omits essential selection and invocation details.

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 confusing multi-property input schema and the absence of annotations, the description is not complete enough to call correctly. It does not specify which parameter to supply, whether that parameter is required, what the output shape is, or how failures are reported. An agent would be guessing between city, url, host, and path.

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 adds no mapping to parameters. Although the schema has per-property descriptions, the only plausible geo-related property is city, and its description says it is for a 'public weather hint' and is discarded—this reads like weather context rather than a geocoding input. The other properties (ref, url, feed, host, json, path) are not explained in relation to returning latitude and longitude.

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 deliverable—latitude and longitude for a place—and identifies the provider, Open-Meteo, which distinguishes it from a weather lookup. However, it is phrased as a noun fragment rather than an explicit 'uses X to return Y' statement, and the schema's many unrelated properties (ref, feed, json, path) leave ambiguity about what counts as a '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?

No guidance is given about when to call geo-hint versus siblings like weather-hint, domain-shape, or lib-docs-hint. The description mentions only the provider, giving no decision criteria, prerequisites, or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Parse', but does not explain whether the tool validates the URL, what happens on invalid input, whether it performs network access, or what the result looks like. The input schema's 'discarded after the shape check' phrasing hints at side-effect-free behavior, but the description itself does not disclose 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, front-loaded sentence with no filler, which is highly concise. It is slightly too sparse given the nine-parameter schema and missing behavioral details, so it earns a 4 rather than 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 description is not complete enough for confident invocation: the tool has nine optional parameters, no required parameters, no output schema, and no annotations. The description only explains one conceptual operation and never tells the agent which parameter to populate, what the other parameters do in this context, or what return value 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?

Schema coverage is 100%, so the schema already documents all nine parameters. The description adds GitHub-specific context for the `url` parameter, but it does not clarify how the other eight unrelated parameters should be handled, and the schema's own `url` description ('HTTPS URL to normalize or cite') conflicts somewhat with the 'parse owner and repo' framing.

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

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

The description states a specific action ('Parse') and object ('owner and repo from a GitHub URL'), making the tool's core purpose immediately understandable. It is naturally distinct from sibling shape tools like jira-key-shape or figma-url-shape, though it does not explicitly name an alternative.

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

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

The intended use is implied: use this tool when you need to extract owner and repo from a GitHub URL. However, it provides no explicit guidance about when not to use it or how it compares to related tools such as normalize-url 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?

No annotations are provided, so the description must carry the behavioral burden. It discloses that this is a live count and that titles are discarded, implying a read-only, count-only operation. It does not mention network dependency, rate limits, or the exact return format beyond the implied number.

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

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

Two short sentences with the main purpose front-loaded and no filler. Both sentences carry meaning: the first states what the tool does, the second explains a key behavioral limitation.

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

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

For a tool with nine optional parameters and no output schema, the description omits the input contract: an agent cannot tell whether to pass a feed, URL, or nothing, or what the count result looks like. The cryptic 'Titles discarded' is the only hint about output. More context is needed to invoke it confidently.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds no parameter-level meaning and fails to explain why nine unrelated optional parameters (city, zone, json, etc.) appear or whether any should be passed. The schema itself documents each parameter, but the description does not bridge them to the tool's purpose.

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

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

The description names a specific verb ('Count'), a specific resource ('current Hacker News front-page stories'), and a behavioral qualifier ('Title discarded') that implies a count-only result. It is clear on its own, though it does not explicitly contrast with sibling tools like web-fetch or fetch-status.

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

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

It implies when to use it: when a count of current Hacker News front-page stories is needed, and 'Titles discarded' hints not to use it when titles are wanted. However, it provides no explicit alternatives or when-not conditions, and it does not clarify how to select among the nine optional parameters.

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

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

There are no annotations, so the description must carry the full behavioral burden, but it discloses almost nothing about side effects, return values, or side effects. It does not clarify whether the tool returns a list, validates an input, or performs any action; the parameter descriptions mention values being 'discarded', but the top-level description never reconciles that behavior with 'IANA timezone names'.

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

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

The description is short, but it is an under-specified fragment rather than a compact, well-structured sentence. It communicates a vague topic without a clear verb or object, so it does not provide the structural cues needed for tool selection or invocation.

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

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

For a tool with seven optional string parameters, no output schema, no annotations, and a description that conflicts with the parameter list, the definition is grossly incomplete. An agent cannot determine which input to provide, what output to expect, or whether the tool performs inspection, transformation, or lookup.

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 seven parameters have schema descriptions, the top-level description adds no parameter-level meaning and does not map 'IANA timezone names' to any declared parameter. No parameter represents a timezone, and the description gives no hint about which of ref, url, city, feed, host, json, or path should be supplied to obtain the promised zone names.

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 mostly restates the tool name and never states an action like 'list', 'return', or 'validate'. It also does not distinguish this tool from sibling tools such as 'timezone' or 'utc-time', and the input schema is filled with unrelated parameters like url, city, json, and path.

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 alternatives like 'timezone' or 'utc-time'. The phrase 'for clock calls' hints at a context but provides no conditions, exclusions, or examples, so an agent cannot determine the appropriate invocation scenario.

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 all behavioral disclosure. It does not mention read-only behavior, network access, failure modes, or side effects, and the parameter descriptions actually obscure the tool's behavior.

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

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

The description is a single, direct sentence with no filler, front-loading the main action and result.

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

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

Given nine parameters, no output schema, and no annotations, the description is far too incomplete. It fails to specify which parameter contains the robots.txt URL, what 'group counts' means, or what output shape 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?

Although schema descriptions cover 100% of parameters, they are generic and mismatched (e.g., 'City name for a public weather hint', 'Git ref name'), adding confusion rather than meaning for a robots.txt fetch. No parameter is clearly connected to the tool's purpose.

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

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

The description is specific: it names the resource (public robots.txt), the action (fetch), and the result (group counts only). This clearly distinguishes it from sibling tools like web-fetch or normalize-url.

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

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

No guidance is provided on when to use this tool instead of alternatives, prerequisites, or expected inputs. The description only states what it does, not 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?

The only disclosed behavior is 'Key discarded', which hints at non-persistence but is ambiguous because the key is not a defined parameter. With no annotations present, the description leaves most side effects, return behavior, and error cases undisclosed.

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

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

The description is only two short sentences with no filler or repetition. It is concise, though the brevity comes at the cost of necessary parameter mapping.

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 cannot be correctly invoked from this description because the Jira key is never mapped to a schema property. There is no output schema, no annotation, and no mention of what the shape check returns, making the definition fundamentally 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 individually explain each parameter, so schema coverage is high, but the tool description identifies no parameter that carries the Jira key. This mismatch means the description adds no useful semantics and may actively mislead an agent trying to select the correct argument.

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

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

The description states a specific action, 'Check a Jira issue key shape', but it never connects that action to any of the seven input parameters, none of which is named 'key'. 'Key discarded' adds confusion rather than clarity because the key value is never shown to be an input.

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 siblings like domain-shape or github-repo-shape. It neither explains expected inputs nor excludes alternatives.

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

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

The phrase 'Body discarded' discloses a behavioral trait beyond the schema: the tool returns only HTTP status and discards the body. With no annotations present, the description carries the full burden, but it only covers this one behavior and omits other traits like error behavior, auth requirements, 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 two short sentences with the core purpose front-loaded and no filler. Every word contributes value, especially the useful 'Body discarded' clarification.

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 7 parameters, no output schema, and no annotations, the description is far too thin. It explains only the URL/status behavior and leaves the agent unable to determine how or when to provide ref, city, json, path, feed, or host. Selection among the many parameters is left completely unexplained.

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 high: all 7 parameters have meaningful descriptions, so baseline 3 applies. The tool description itself adds no parameter-level meaning, and its single-purpose framing (public library docs URL) potentially obscures the purpose of unrelated params like city and json, though it doesn't directly contradict them.

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

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

The description names a specific verb and resource ('HTTP status' for 'a public library docs URL'), which clearly states the core action. However, it doesn't differentiate the tool from sibling tools such as fetch-status or browser-url-ok, and the mention of 'public library docs' conflicts with the schema's generic parameters like city and json, reducing clarity.

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

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

There is no guidance on when to use this tool instead of siblings like fetch-status, normalize-url, or web-fetch. The description does not mention any conditions, exclusions, or situations that would direct an agent to choose this tool over alternatives.

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

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

With no annotations, the description carries the full burden, but it only says 'Values discarded.' It does not disclose whether nested keys are counted, what the return value looks like, what happens if no relevant input is supplied, or whether passing multiple parameters counts each key or only the `json` parameter. The one behavioral hint is useful but far from sufficient.

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

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

The description is extremely concise and front-loaded: two short sentences with no filler. Every sentence contributes meaning. However, it is so sparse that it omits critical invocation information, so it earns a 4 rather than 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?

For a tool with 9 optional parameters, no output schema, no annotations, and 26 sibling tools, this description is incomplete. It does not explain which parameter carries the JSON object, why the other parameters exist, what the count represents, or what the return value is. An agent cannot confidently 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?

Although schema description coverage is 100%, the parameter descriptions are confusing and often unrelated to counting keys. Several params are described with domain semantics like 'City name for a public weather hint' or 'JSON text to validate', all while saying values are discarded. The top-level description never identifies which parameter should contain the JSON object whose keys are counted.

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 keys in a JSON object' and that values are ignored, which is more than a tautology. However, it does not say which JSON object is meant: the tool's own argument object, a JSON string passed in the `json` parameter, or some other memory object. This ambiguity weakens its clarity.

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

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

No usage guidance is provided. The description does not say when to use this tool instead of a sibling like validate-json, nor does it mention any exclusions or alternatives. An agent gets no help deciding whether this is the right tool for counting top-level keys versus validating or parsing JSON.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose the important behavior that query and fragment are dropped and that only three components are returned. However, it does not explain other normalization behaviors implied by the name, such as handling of case, default ports, or invalid URLs, nor does it state that apparently unrelated 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 the primary behavior front-loaded and the query/fragment caveat placed second. There is no filler and no repetition of schema content.

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

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

For a simple read-only normalization tool with no output schema and no annotations, the description is mostly complete: it names the output fields and the key transformation. It would be clearer if it explicitly stated that all parameters other than url are ignored, but an agent can still 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 already provides descriptions for all parameters, so the baseline is 3. The description adds little parameter-level meaning beyond indicating that the URL is the input, and it does not resolve the ambiguity that host and path appear both as output concepts and as input-schema properties.

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

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

The description uses a specific verb ('Return'), names the resource ('a URL'), and lists the exact output fields (origin, host, path) plus the key caveat that query and fragment are dropped. This clearly distinguishes it from sibling fetch/check tools like web-fetch or browser-url-ok.

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

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

The intended use is implied: an agent should call this when it needs normalized origin/host/path components. However, there is no explicit 'use when' guidance, no named alternatives, and no 'do not use if' condition beyond the behavioral note that query and fragment are dropped.

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

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

With no annotations, the description carries the disclosure burden; it does state a meaningful trait (no browser is launched). However, it leaves unspecified whether a network request is made, what 'can be opened' means, and how errors/statuses are 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?

Two short sentences, all substance and no filler. The action is front-loaded and the key behavioral nuance follows immediately.

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

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

The definition is adequate for a simple boolean check, but no output schema or return contract is provided, and 'can be opened' is left undefined. The optional parameters and their schema descriptions are well documented, so the main gap is the tool's outcome semantics.

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

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

Schema description coverage is 100%, so the baseline is 3 and the description adds no parameter-level meaning. The description doesn't help disambiguate which of the optional parameters are relevant to a URL-ok check.

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

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

The description has a specific verb ('Check') and resource ('URL'), and 'No browser is launched' clarifies the mechanism. It is clear about what the tool does, though it doesn't explicitly contrast it with the sibling 'browser-url-ok'.

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

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

The description gives no when-to-use guidance or alternatives. 'No browser is launched' implies a lightweight check, but the tool never says to prefer it over browser-url-ok, fetch-status, or normalize-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 description notes that the query is 'discarded', giving a hint about data handling. However, it does not disclose behavior regarding the other parameters, whether network requests are made, or any side effects. With no annotations, this transparency is insufficient.

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, consisting of two short sentences. It is well-structured and free of unnecessary content, achieving high efficiency.

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 complexity of 9 parameters, the description is grossly incomplete. It provides no context on why the tool accepts many unrelated fields (e.g., url, city, timezone) or how they relate to counting characters in a query. An agent would struggle to determine proper usage or expected 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?

Schema description coverage is 100%, so parameter descriptions are already provided. The tool description adds no extra semantic meaning beyond mentioning 'query', which aligns with the schema. It does not clarify whether other parameters are ignored or affect the result.

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

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

The description clearly states the tool's function: count characters in a search query. The verb 'count characters' is specific and the resource 'search query' is unambiguous. However, it does not explicitly mention that other parameters are ignored, which could cause confusion given the schema has 9 fields.

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 usage guidance is provided. The description does not indicate when to use this tool versus alternatives like memory-key-count or hn-front-count, nor does it explain the relevance of the other schema parameters.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. The description only states 'Short catalog of common HTTP status codes.' and does not reveal what the tool does with its nine inputs, what it returns, or any side effects, even though parameter descriptions hint at discarded values.

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 wasted words, so it is concise and easy to parse. However, it is so minimal that it sacrifices substance, though conciseness itself is well achieved.

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

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

For a tool with nine parameters, no annotations, and no output schema, a one-line noun phrase is severely incomplete. The description does not explain how the parameters relate to the catalog, what the tool produces, or when to call it, leaving major gaps 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?

The input schema includes nine properties, each with a description, providing 100% coverage of parameter semantics. The description adds nothing extra, but with full schema coverage 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 identifies the resource as 'common HTTP status codes' and implies a catalog, so an agent can guess it provides a list. However, it lacks an explicit verb like 'returns' or 'lists', making the action vague. It does not distinguish itself from similar siblings such as fetch-status.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or comparison to any sibling tool, leaving the agent without direction.

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

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

With no annotations, the description carries the full burden. It discloses a key non-obvious behavior: the prompt and all parameters are discarded, so the tool performs no processing or persistence of inputs. It would be even stronger if it explicitly stated the tool has no side effects or output beyond the template.

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?

Both sentences are short and front-loaded; the main behavior is stated first. 'Prompt discarded' is somewhat cryptic and could be ambiguous, but it does carry meaningful behavioral information and earns its place.

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

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

For a simple no-required-params tool, the description suffices: an agent knows it returns a fixed template and that inputs will be ignored. The purposefully redundant parameter list might confuse, but the schema descriptions and the discarded prompt statement together clarify the contract.

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

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

The input schema already has detailed descriptions for each parameter, including the 'discarded' behavior for most. The description adds no parameter-level information, so it neither compensates for gaps nor conflicts with the schema. Baseline 3 is appropriate since schema coverage is high.

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 a three-step thinking template, which is a specific verb+resource. The phrase 'Prompt discarded' adds an important boundary, distinguishing it from tools that process input. However, it does not explicitly say what the template is for or how it relates to the 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?

Usage is implied: an agent would call this when a thinking template is requested. 'Prompt discarded' hints at an exclusion, but there is no explicit statement of when to use this versus alternatives, nor any mention of choosing it over sibling shape-check or fetch tools.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only states the core action and omits any mention of return format, error behavior, or the obvious mismatch between the tool's purpose and the unrelated input schema.

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

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

The description is a single clean sentence that front-loads the core purpose without wasted words. It is appropriately terse, though the brevity does not compensate for the serious schema mismatch.

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 an input schema full of unrelated parameters and no output schema, the description is insufficient for correct invocation. It neither explains how to provide the timezone argument nor what the other parameters do, leaving a critical gap in operational knowledge.

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 contains parameters for ref, url, city, feed, host, json, and path, but none of these corresponds to a timezone name, and the description adds no mapping. The agent cannot determine which parameter should hold the IANA timezone, making the tool effectively uncallable as described.

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: it returns the current time for a named IANA timezone. This is clear and distinct from the sibling utc-time, but it does not explicitly name any alternatives, so it stops short of a full 5.

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

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

There is no guidance on when to use this tool versus siblings like utc-time or iana-zones. No context, exclusions, or alternative tools are mentioned, leaving the agent to infer usage entirely.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only says 'Current UTC timestamp.' It does not state that the tool performs no side effects, requires no meaningful arguments, or that the listed parameters are ignored or discarded. The parameter descriptions hint at discarding, but the tool-level description leaves this behavior 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, front-loaded phrase with no wasted words. It is appropriately concise for a trivial tool, though it is so terse that it misses important behavioral context.

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

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

Given a surprisingly complex schema with 9 optional parameters, no annotations, and no output schema, the description is incomplete. It does not explain whether the parameters affect behavior, how the output is formatted, or why such a simple tool accepts these inputs. An agent would likely be confused about whether to pass 'city' or 'json' even though neither is needed.

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. The tool description adds nothing about parameters, but because each parameter already has a meaningful, if odd, description, the schema itself carries the semantic load. The description could have clarified why parameters like 'feed' and 'json' appear for a UTC timestamp tool.

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

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

The description clearly indicates the tool's purpose: returning the current UTC timestamp. It is specific enough to be distinguished from most sibling tools by the resource and value it exposes, though it lacks an explicit verb and does not explicitly differentiate itself from the sibling 'timezone'.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'timezone' or 'iana-zones'. It also does not mention that all 9 input parameters are optional and irrelevant to the timestamp output, leaving the agent without direction on how to invoke 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?

No annotations are provided, so the description must carry the full burden of explaining behavior. It discloses that the body is discarded, implying no persistence, but it omits the return value, error behavior, 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 short and front-loaded, with the key behavioral caveat ('discarded') included in the second sentence. It is concise, though the vague use of 'body' prevents a perfect score.

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

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

With nine parameters, no annotations, and no output schema, the description is under-specified. It lacks return format, invocation pattern, and any explanation of how the unrelated optional parameters relate to JSON validation.

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 explained in the schema. The tool description adds no additional meaning and does not clarify how 'body' maps to the 'json' parameter, so the baseline of 3 is appropriate.

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

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

The description states a concrete action ('Check whether a body is valid JSON') and names the resource clearly. It doesn't explicitly distinguish from sibling validators, but the JSON focus is unique enough among the sibling names.

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 sibling shape/URL/file validators, and no mention of what input should be supplied. The description does not say when to choose validate-json over alternatives or when not to use it.

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

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

With no annotations, the description must carry behavioral transparency, but it only states what the tool returns. It does not disclose side effects, read-only behavior, or that most parameters are discarded.

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

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

The description is a single, focused sentence with no redundant wording. It is easy to parse and directly states the primary function.

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 omits the output format, required inputs, and how to handle the nine parameters. With no output schema, an agent cannot confidently know what response to expect or which parameters are actually needed.

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 100% description coverage, so the baseline is 3; however, many parameter descriptions are generic and unrelated to weather, and the city description says it is discarded. The description itself adds no parameter clarification beyond the schema.

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

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

The description clearly states the tool returns the current temperature for a city using Open-Meteo. It is specific about the action and data source, though it does not explain why the parameter list includes many unrelated fields.

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 sibling tools such as geo-hint or web-fetch. The description does not mention alternatives, prerequisites, or typical query scenarios.

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 usefully discloses that the body is discarded and that the URL must be public, but it does not cover redirects, timeouts, authentication needs, or error behavior, which are relevant for a network-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?

Two short sentences with no filler. The primary purpose is front-loaded, and the body-discard caveat is stated separately and economically.

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 covers the returned values but leaves invocation ambiguous: there are nine optional parameters with no required field, no output schema, and no indication whether non-URL parameters are accepted. Given the broad schema and sibling overlap, an agent could not be fully confident about building the correct 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?

All parameters have schema descriptions, so the baseline is 3. The tool description adds no clarification about which of the nine optional parameters is the intended URL input, and the schema's own `url` description (normalize or cite) is somewhat at odds with fetching, leaving 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 names concrete outputs (HTTP status and content type) for a public URL and adds that the body is discarded, which is a clear, non-tautological purpose. It does not explicitly differentiate from siblings like fetch-status or browser-url-ok, but the content-type and body-discard scope gives enough identity.

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

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

The intended use is implied: check HTTP status/content type of a public URL when the body is not needed. However, it never names alternatives or states when not to use this tool, and with many overlapping URL sibling tools the lack of explicit routing is a noticeable gap.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses one useful trait—'Title discarded after the call'—but says nothing about read-only behavior, network access, error handling, or the shape of the response, leaving the agent under-informed about side effects and expectations.

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, front-loaded with the main purpose, and the retention caveat is useful and non-redundant. It lacks more detailed structure, but as far as conciseness goes, every word earns its place.

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

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

For a 7-parameter tool with no annotations and no output schema, this description is severely incomplete. The necessary input is ambiguous, the expected return value is undocumented, and the behavior beyond 'title discarded' is unexplained, so the agent would be guessing at correct usage.

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

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

Although the schema descriptions cover 100% of the parameters, none of them maps to a Wikipedia title: ref is a Git ref, url/feed/host are network strings, json is JSON text, and path is a file path. The description does not explain which field carries the title, so an agent cannot reliably invoke this tool correctly.

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

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

The description clearly states the operation ('Check whether') and the resource ('a Wikipedia title'), so an agent can tell what the tool does. It does not connect this purpose to any specific input parameter or distinguish itself from sibling validation tools, so it falls just short of a 5.

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

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

No guidance is given about when to use this tool versus alternatives such as normalize-url, fetch-status, or validate-json. The only usage signal is implicit in the name and phrase 'Check whether a Wikipedia title exists,' with no when-not-to-use conditions or alternative routing.

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