ISO country NU

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

No annotations are provided, so the description carries the burden. It explicitly states that task text is discarded and lists what the tool returns. It does not discuss auth, rate limits, or side effects, but the phrase 'public pay-per-call' hints at external constraints.

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?

Three short, information-dense sentences with no filler. The key behavioral warning 'Task text discarded' is included succinctly.

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

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

Without an output schema, the description usefully names the returned artifact types and input handling behavior. It leaves response format details unspecified, but the schema covers parameter-level 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?

The input schema already documents all parameters and their discard behavior, so the description adds little beyond what structured data provides. Baseline 3 is appropriate due to high schema coverage.

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

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

The description clearly states the tool finds a public pay-per-call tool gateway (Monid) and lists the returned artifacts: CLI setup, how-it-works, skill file, and remote MCP hops. It does not explicitly differentiate from sibling tools, so it stops short of a 5.

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

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

The intended use is implied: when an agent needs the Monid gateway, CLI setup, or remote MCP hop information. However, there is no explicit when-not-to-use guidance or comparison with sibling tools.

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

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

With no annotations, the description carries the full burden, but it only reveals one behavior (no browser launch). It does not say whether a network request is made, what 'ok' means, whether the call is read-only, or what is returned. The no-browser detail is useful but 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?

Two short sentences, front-loaded with the main action, and no filler. The sentence 'No browser is launched' earns its place as an important behavioral caveat, though the description is too sparse for the complexity of the 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?

For a tool with nine optional parameters, no output schema, and no annotations, this is not enough context. An agent cannot tell which parameter is needed, what result to expect, or how the check is performed; the description only covers the existence of a URL check.

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 property descriptions do not align with the stated purpose: the url parameter is described as 'HTTPS URL to normalize or cite', not as a URL to check for openability. The description adds no guidance about which of the nine optional parameters to pass and what each means for this tool.

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

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

The description names a concrete action and resource: check whether a URL can be opened. It also includes a useful boundary ('No browser is launched'), which helps separate it from browser-based siblings. However, 'can be opened' is not defined (syntax check, reachability check, or browser compatibility), so it is not fully specific.

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

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

The only usage signal is the negative behavior 'No browser is launched'; there is no explicit statement of when to choose this tool over normalize-url, fetch-status, web-fetch, or playwright-url-ok. An agent must infer the appropriate context instead of being told.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It adds one useful fact ('Expression discarded'), but it omits what the operation returns, whether there are side effects, and whether anything is retained. The term 'expression' also does not map to any actual schema 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?

The two sentences are short and front-loaded with no filler, but the description is under-sized for a tool with nine parameters and no annotations. It earns its place only as a minimal summary, not as an adequate spec.

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?

Nine unannotated parameters, no output schema, and a large sibling set require far more context than this. The description omits return behavior, parameter mapping, prerequisites, and any relationship to sibling tools, so it is not complete enough for reliable selection and invocation.

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

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

Although each schema property has its own description and coverage is 100%, the tool description mentions an 'expression' that does not exist among the nine parameters. An agent cannot determine which field to populate with an arithmetic expression, so the description actively fails to support invocation.

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 operation and resource: 'Evaluate a+b style arithmetic', which is distinct from the sibling shape/status/URL tools. However, the description never connects that operation to any of the nine schema properties, so the purpose is clear in isolation but not actionable from the schema.

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

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

The phrase 'a+b style arithmetic' implies a narrow use case, but there is no explicit when-to-use guidance, no alternative tools named, and no exclusions. The agent must infer from the name and one clause that this tool is for simple arithmetic evaluation.

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

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

With no annotations, the description carries the full burden and at least discloses that page content is not stored and that output is limited to host/scheme/status. However, it does not explicitly disclose that the tool likely makes a network request, nor does it mention failure modes, redirects, or 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?

Two short sentences with the core behavior front-loaded and a useful privacy note; there is no filler or redundancy.

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

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

The schema exposes nine parameters, several marked as discarded or unrelated to URL citation, yet the description doesn't explain why they exist or that only url should be used. With no output schema and no annotations, an agent lacks enough context to confidently determine the intended invocation and edge 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?

Schema description coverage is 100%, so parameter documentation is already present; the tool description adds no parameter-specific meaning. It does not clarify that only url is relevant while several other fields are discarded, but the schema itself provides those notes.

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 host, scheme, and HTTP status for a URL, with a specific verb and resource. It doesn't explicitly differentiate from siblings like fetch-status or normalize-url, but the precise output list conveys purpose well.

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 fetch-status, normalize-url, or web-fetch, and no conditions or exclusions are mentioned. The statement that page content isn't stored hints at a limitation but does not provide 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?

With no annotations, the description carries the behavioral burden. It adds a meaningful privacy disclosure ('No identifiers are retained') and the schema repeats 'discarded' for each field. However, it does not disclose whether the tool makes external calls, has side effects, or what the classification output 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?

Two direct sentences with no filler: one states the action, the other the retention guarantee. The structure is front-loaded and easy to parse.

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

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

For a tool with nine optional parameters, no output schema, and no annotations, this description is incomplete: it does not say what classification result is returned, which parameter(s) should be supplied, or whether multiple parameters can be passed at once. The privacy note is useful but not enough for confident invocation.

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

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

Schema description coverage is 100%, so the parameters are already individually documented. The description adds no extra parameter-level meaning beyond implying they are candidate inputs for classification, which is acceptable at the baseline.

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

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

The description states a clear verb and object ('Show how this request is classified'), which is more than a tautology, but it never defines what classification categories are produced or what distinguishes this tool from its many siblings. An agent can infer it routes or classifies inputs, but only by leaning on the sibling list and schema.

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

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

No guidance is given about when to call this tool as opposed to normalize-url, validate-json, weather-hint, or the other sibling tools. The description does not mention alternatives, prerequisites, or when classification is the right step.

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 that no WHOIS/ownership lookup occurs, but it does not state what the tool returns, how invalid hostnames are handled, whether network access is involved, or that most schema parameters are 'discarded after the shape check'. The schema's parameter descriptions cover some of this, but the description itself adds too little 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?

The description is a single sentence with no filler, front-loading the action ('Split a hostname') and adding one useful caveat ('without WHOIS or ownership data'). Every word earns its place within the limited scope the text attempts to convey.

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 surface is complex: nine optional parameters, no required fields, no output schema, and no annotations. The one-line description omits how to select among parameters, what output format to expect, and what happens with irrelevant parameters. An agent can guess the happy-path 'host' invocation, but the description is far from complete for correct and robust selection.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaning for the 'host' parameter by tying it to hostname splitting, but it stays silent on the other eight parameters and does not clarify whether they are alternatives or all accepted independently. This keeps it at baseline rather than above 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 states a specific verb and resource ('Split a hostname into labels') and adds a useful exclusion ('without WHOIS or ownership data'), so the core operation is clear and distinguishable from lookup-style sibling tools. However, the schema advertises nine optional parameters that the description never reconciles, so the description under-represents the actual tool surface.

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

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

There is no when-to-use guidance, no mention of alternatives, and no instruction that the 'host' parameter is the one to pass for domain splitting. The 'without WHOIS or ownership data' phrase is a negative scope limitation, not a decision rule. With nine optional parameters, the agent has no basis for choosing among 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?

With no annotations, the description carries the burden of behavioral disclosure, and it does reveal the HTTP method, the public scoping, and the status-only output. That is meaningful, but it does not explain the unusual presence of nine discarded or unrelated input fields, nor error/redirect/timeout 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, which is efficient. It loses a point because the brevity leaves the nine-parameter schema unexplained, creating confusion rather than reinforcing clarity.

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, no output schema, and a large sibling set, one sentence is insufficient. The description omits any explanation of the extra parameters, the relationship to sibling tools, or behavioral edge 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?

Schema description coverage is 100%, so the baseline is 3 and most parameter meaning is already in the schema. The description adds clarity only for the URL parameter's intended role (HEAD and status only), while the schema's own 'url' description contradicts that role by saying 'normalize or cite.'

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

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

The description clearly states a specific verb, resource, and output: 'HEAD a public URL and return status only.' This distinguishes it from content-fetching tools like web-fetch. However, the nine-parameter schema introduces ambiguity because most parameters are unrelated to a HEAD request, and the 'url' parameter description says 'normalize or cite' instead of 'HEAD.'

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

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

The description provides no explicit when-to-use guidance or exclusions relative to the many siblings such as browser-url-ok, web-fetch, or normalize-url. The phrase 'status only' implies a comparison, but the tool never names alternatives 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does state one useful behavioral fact: the path is discarded. However, it does not say whether this is a read-only parse, what it returns, how errors are handled, or whether any network access is involved.

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

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

The description is very short and front-loaded, with no filler. 'Path discarded' is a meaningful, compact behavioral note. It is slightly terse, but the structure is clear and scannable.

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 input parameters, no annotations, and no output schema, yet the description only states the resource and one behavioral detail. It does not describe expected return values, failure modes, or how this tool relates to the many sibling shape/URL tools, so an agent is under-informed for reliable invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds minimal parameter-level value beyond 'Path discarded', which clarifies that path is ignored rather than used, but it does not help an agent understand which of the many other parameters apply to this tool.

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

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

The description names a specific verb ('Parse') and a specific resource ('a Figma file URL'), so an agent can identify what this tool operates on. It does not explicitly contrast with sibling tools like github-repo-shape or jira-key-shape, but the Figma scope makes the purpose reasonably clear.

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

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

There is no guidance on when to use this tool versus alternatives such as normalize-url, browser-url-ok, or other -shape tools. The description only states what the tool parses, not the conditions or context in which it should be selected.

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 one important behavior: no disk access, meaning the check is purely syntactic/shape-based. It does not disclose return format, failure behavior, or what 'safe' means, so transparency is partial.

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

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

Two short, front-loaded sentences with no filler. Every phrase earns its place: what it checks and the key safety constraint.

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 concise language, the description is incomplete for an unannotated tool with nine optional parameters and no output schema. It omits the return value, the criteria for 'safe', and how to handle or choose among the non-path fields, so an agent may be unsure how to invoke it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3; the description adds no parameter detail beyond confirming the path is the subject. The schema's per-parameter descriptions already document all nine optional fields, including which are discarded.

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

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

States a specific verb and resource ('Check whether a path looks safe') and adds a key constraint ('No disk access'). It clearly identifies what the tool evaluates, although 'safe' is left undefined and no sibling differentiation is explicitly named.

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 when-to-use or when-not-to-use guidance is given; the only hint is the no-disk-access constraint, from which an agent can infer it is for syntactic path checks. It does not compare against sibling validators such as wiki-title-ok or browser-url-ok, so usage guidance is mostly implied.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only reveals that Open-Meteo is involved; it does not state that this is a read-only network lookup, whether inputs are discarded, or what failure modes exist. The schema's 'discarded after...' notes are not part of the tool 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 sentence is short and front-loaded with no wasted words, which is good. However, for a tool with nine optional parameters and many close siblings, a single noun-phrase sentence is too terse to provide the structure an agent needs to invoke it correctly.

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

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

The description is incomplete for correct invocation. It does not specify which parameter identifies the place, what the returned latitude/longitude format is, or whether the other parameters are ignored. With no output schema and no annotations, the agent is left with substantial ambiguity.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description adds no parameter-level detail. The description implies a place input but never maps that concept to any of the nine schema fields, leaving the agent to guess whether city, query, or another parameter 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 identifies the output (latitude and longitude), the target (a place), and the backing service (Open-Meteo). This is enough to distinguish geo-hint from weather-hint and URL-check siblings, though it lacks an explicit verb like 'resolves' or 'returns'.

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 prefer geo-hint over alternatives like weather-hint, nor does it clarify that it should be used specifically for geocoding a city or place name. All selection logic is left to inference.

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

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

No annotations are provided, so the description carries the behavioral burden. 'Parse' implies a pure, non-mutating transformation, which is helpful, but the description does not disclose behavior on invalid or non-GitHub URLs, nor does it state that non-url parameters are ignored. The schema partially covers this, but the description itself is 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 a single front-loaded sentence with zero filler. Every word contributes to the tool's purpose and input type, making it easy for an agent to parse quickly.

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

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

The tool is simple and the description names the intended outputs, but with no annotations and no output schema, some gaps remain: there is no stated handling of invalid URLs, no explicit indication that 'url' is effectively required despite zero required parameters, and no mention of return format. Given the number of optional parameters, an agent could be uncertain about what 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?

Schema coverage is 100%, so the baseline is 3 even without parameter details in the description. The description adds mild value by clarifying that the GitHub URL is the relevant input and that owner/repo are the outputs, but it does not explain parameter roles beyond what the schema already states.

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

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

The description uses a specific verb ('Parse') with a clear resource: owner and repo extracted from a GitHub URL. It differentiates itself from sibling shapes like domain-shape and figma-url-shape by naming GitHub explicitly. A single sentence is enough to tell an agent what this tool achieves.

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

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

The description clearly implies the tool is appropriate when the agent has a GitHub URL and needs the repository's owner and repo name. It does not explicitly name alternatives or exclusions, but the GitHub-specific framing gives enough context to select it over related shape/validation tools.

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

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

With no annotations provided, the description carries the full burden. It clearly implies a read-only counting operation and explicitly says titles are discarded, which is useful behavioral context. However, it does not disclose network behavior, output format, or what happens with the various input parameters beyond a few schema-level 'discarded' hints.

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

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

The description is two short sentences with no filler. The primary action and target are front-loaded, and the additional 'Titles discarded' sentence earns its place by clarifying output scope.

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 clear enough for selecting the tool, but it is incomplete for correct invocation: it fails to explain the role of the 9 optional parameters, whether any input is needed, or what the return value looks like. With no output schema and no annotations, an agent is left guessing how to call this tool correctly.

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

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

Schema description coverage is 100%, so every parameter already has a description and the baseline is 3. The tool description itself adds no parameter-level meaning and does not clarify which of the 9 optional parameters actually matter for counting Hacker News front-page stories.

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

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

The description states a specific verb and resource: 'Count current Hacker News front-page stories.' It also adds a useful scoping detail, 'Titles discarded,' which clarifies what is not returned. No sibling tool appears to overlap with this purpose.

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

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

The description gives no guidance on when to use this tool versus alternatives, and it does not state whether the 9 optional parameters are needed or should be ignored. It relies entirely on the tool name and first sentence to imply usage.

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 content of the tool ('common IANA timezone names') and does not describe whether it returns a list, whether inputs are ignored, how results are sorted, or any other behavioral characteristics.

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

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

The description is a single short sentence with no filler or redundant information. It is appropriately concise, though it lacks a verb and reads somewhat like a fragment rather than a complete tool description.

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

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

There is no output schema and no annotations, and the tool has 9 optional parameters, yet the description does not state what the tool returns, whether parameters affect the result, or how this relates to sibling clock/timezone tools. An agent could call it correctly only by guessing.

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 of 3 applies even though the tool description adds no parameter-specific meaning. The parameter descriptions themselves are generic and seem unrelated to timezone names, but the description does not need to compensate for schema coverage that already exists.

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

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

The description is a noun phrase rather than a clear verb+resource statement, so it does not explicitly say whether the tool lists, returns, or validates timezone names. It does convey that the subject is common IANA timezone names and that they are meant for clock calls, but it does not distinguish this tool from siblings like timezone or utc-time.

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

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

The phrase 'for clock calls' implies when the tool might be useful, but it provides no explicit guidance on when to choose iana-zones over alternatives, nor does it mention any exclusions or relationships to sibling tools. An agent is left to infer 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?

With no annotations, the description carries the transparency burden. It discloses that the tool performs a network fetch, targets public robots.txt files, and returns only group counts. However, it does not describe failure modes, redirect behavior, rate-limit risks, or the exact shape of the returned counts.

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

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

The description is a single, front-loaded sentence with no filler. It communicates the operation and the output restriction in ten words, making it easy for an agent to parse quickly.

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 too thin for a tool with 9 optional parameters and no output schema. It leaves unresolved which parameter identifies the robots.txt source, what the group-count result structure looks like, and how errors or missing robots.txt files are handled. An agent cannot confidently invoke it correctly from this description alone.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-specific meaning and does not say whether 'host' or 'url' should be used to supply the robots.txt target. This ambiguity is notable, but the schema itself does describe every 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 names a specific verb ('Fetch'), a specific resource ('a public robots.txt'), and a specific output scope ('group counts only'). This clearly distinguishes the tool from generic web fetching or URL-checking siblings such as web-fetch and 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?

No guidance is given about when to choose this tool over sibling tools like web-fetch or normalize-url, and no conditions or exclusions are mentioned. The description implies usage for robots.txt inspection, but leaves the selection logic entirely to the agent.

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. The note 'Key discarded' is a minimal side-effect disclosure but is ambiguous because the actual 'key' parameter is not identified. No information is given about return values, errors, or validation criteria.

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 this is under-specification rather than genuine conciseness. It omits essential operational details, making it similar to the 'Process' example where brevity reflects missing substance.

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, no output schema, and no annotations, the description needed to compensate but is nearly empty. An agent cannot figure out which parameter to populate, what the output looks like, or how the shape check behaves. This is a critical completeness failure.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning and fails to map the concept of 'key' to any schema property, which is a notable gap. However, since every parameter already has a schema description, the negative impact is limited.

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

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

The description states a specific verb and resource ('Check a Jira issue key shape'), and the name echoes the intent. However, the 9-parameter input schema contains no 'key' parameter, so the agent cannot determine which field actually holds the Jira key. This ambiguity undermines clear purpose.

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

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

The description provides no guidance on when to use this tool versus sibling tools like domain-shape or github-repo-shape. There is no mention of alternatives, exclusions, or any contextual conditions for invocation.

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 behavioral burden. It discloses one useful trait (the body is discarded), but it does not clarify that many schema parameters are 'discarded after...' checks, what happens on network or fetch failures, whether authentication is needed, or what the response format will be.

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 behavior front-loaded and no filler. It is admirably concise, though so terse that it leaves necessary operational context out.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, this description is materially incomplete. It explains only the library-docs-URL case and says nothing about the other parameters, the return shape, error behavior, or how the tool behaves when multiple parameters are supplied.

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

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

Schema description coverage is 100% and every parameter already has a description, which sets the baseline at 3. The tool description adds only a loose connection to the 'url' parameter and does not help an agent choose among the nine optional parameters or understand which ones actually apply to this tool.

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

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

The description names a concrete action and resource: it returns the HTTP status of a public library docs URL and discards the body. This is clear about the main use, though it does not name sibling tools or explain how it differs from fetch-status or web-fetch, and the schema's many unrelated optional parameters blur the overall scope.

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

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

There is no explicit guidance about when to use this tool instead of fetch-status, web-fetch, browser-url-ok, or other sibling tools, and no when-not-to-use conditions. 'Body discarded' only implies lightweight status checking; it does not state alternatives or decision rules.

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 absent, so the description carries the full burden of behavioral disclosure. It discloses one trait ('Values discarded'), which is corroborated by the schema's repeated 'discarded after...' phrasing, but it says nothing about the return value, behavior for non-object or invalid JSON, or why inputs 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?

Two short sentences, front-loaded with the verb, with zero filler. It is arguably under-specified for a nine-parameter tool, but every word earns its place and the core action is stated immediately.

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

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

With nine parameters, no annotations, and no output schema, the description must do heavy lifting and does not. It fails to explain what the returned count looks like, which parameter (if any) carries the JSON, and what the odd parameter set ('Git ref name; discarded...', 'City name for a weather hint; discarded...') has to do with counting keys.

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 all nine parameters are individually documented and the baseline is 3. The tool description adds no parameter-specific meaning, but the schema already covers each field, including the notable discard semantics.

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') and resource ('keys in a JSON object'), and 'Values discarded' adds a scoping constraint that plausibly differentiates it from the sibling validate-json. However, it never states which JSON object gets counted (a parameter, or the model's memory context), leaving an ambiguous tie between the description and the nine string parameters.

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

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

There is no when-to-use guidance, no exclusions, and no mention of alternatives. With 26 siblings including validate-json, normalize-url, and weather-hint, the agent is given no basis for choosing memory-key-count over any of 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?

There are no annotations, so the description carries the behavioral disclosure burden. It explicitly states that query and fragment are dropped, which is a meaningful transformation behavior beyond just naming the output. It does not discuss invalid URL handling or mention that non-url parameters are ignored, but the schema descriptions already mark those parameters as 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?

Two short sentences with no filler. The first sentence states the core output, and the second adds the key transformation detail. Every clause earns its place, and the most important information is front-loaded.

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

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

Given the 9-parameter schema and no output schema, the description gives the essential return values and the key drop behavior. The schema covers all parameter semantics, including which fields are discarded. It does not explicitly state that only 'url' matters or provide the exact return shape, but the description is still complete enough for a competent 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?

Schema description coverage is 100%, so the baseline is 3. The description adds only the URL-level behavior that query and fragment are dropped; it does not elaborate on any of the nine parameters beyond what the schema already states. This satisfies the baseline 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 uses a specific verb and resource: 'Return origin, host, and path for a URL.' It clearly communicates extraction/normalization behavior and naturally distinguishes it from sibling '*-ok' and '*-shape' tools, which imply validation or shape checking rather than returning URL components.

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

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

The intended use is implied: call this tool when you need origin, host, and path from a URL with query and fragment removed. However, it does not explicitly state when to prefer this over alternatives like browser-url-ok or figma-url-shape, nor does it give any when-not-to-use guidance.

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

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

With no annotations provided, the description must disclose behaviors itself, but it only says no browser is launched. It does not explain whether a network request is made, whether the check is purely syntactic, what is returned, whether any input is mutated, or how the discarded params behave—details the schema mentions but the description should surface.

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 text is very short and front-loaded with no filler words, which is good for conciseness. However, it is under-specified for a tool with seven params and a broader potential scope, so the brevity is not 'appropriately sized'—it reads as an incomplete stub rather than a deliberately minimal but sufficient 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?

Given the tool has seven heterogeneous input params, no annotations, and no output schema, the description is far too thin. It does not say which parameter to pass, what the result means, whether the check is network-based or syntactic, or how this relates to the many sibling check tools, so an agent cannot reliably 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 tool description adds no parameter-level meaning, but the input schema already provides descriptions for all seven parameters (100% coverage), so the baseline is 3. The description's 'URL can be opened' framing actually conflicts with the schema's description of `url` as 'HTTPS URL to normalize or cite', preventing a higher 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 description states a specific action ('Check whether a URL can be opened') and adds a distinguishing caveat ('No browser is launched.'), so an agent can tell this apart from browser-launching tools. However, it is incomplete and somewhat misleading: the input schema accepts seven heterogeneous params (ref, city, feed, json, path, host) and describes `url` as 'normalize or cite', not 'open', so the stated purpose does not cover the tool's actual surface.

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 guidance is given about when to use this tool versus siblings like browser-url-ok, web-fetch, or fetch-status. The phrase 'No browser is launched' hints at a lightweight check, but there is no stated condition or alternative routing, leaving the agent to infer when it should be chosen.

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

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

The description adds one useful behavioral fact—'Query discarded'—which tells the agent the input is not retained. However, with no annotations, the description carries the full burden and still does not state the return type, side effects, or the fact that the other eight schema parameters are effectively irrelevant.

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 action is front-loaded, and 'Query discarded' earns its place as a concise 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?

With 9 optional parameters and no output schema, the description is too sparse. It does not explain that only `query` is relevant, what happens if other fields are supplied, or what the tool returns, leaving an agent with significant ambiguity.

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

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

Schema description coverage is 100%, and the query parameter is already documented as 'Search text; discarded after the length check.' The description adds no new parameter-level meaning beyond the schema, so the baseline of 3 applies.

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

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

The description clearly states the tool counts characters in a search query, using a specific verb and resource. It is not a tautology and would help an agent identify query-length tasks, but it does not explicitly differentiate itself from sibling counting or shape-checking tools like memory-key-count or normalize-url.

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

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

There is no when-to-use instruction, no exclusions, and no mention of alternatives. The description only states the action, leaving usage context to inference; the unusually broad 9-parameter schema makes this gap worse because the description does not say that only the query parameter should be used.

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 absent, so the description carries the full burden of behavioral disclosure. The word 'catalog' weakly implies a read-only, informational tool, but the description does not disclose what the tool returns, whether it performs validation, whether it makes external calls, or what side effects might occur. This is a minimal signal, not adequate 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 very short and has no filler, but it is under-specified rather than appropriately concise. A single noun phrase cannot serve as a usable tool description for a tool with 9 parameters and no annotations. The brevity is not a structural strength.

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 parameters, no annotations, no output schema, and many closely related siblings, the description is drastically incomplete. It does not explain what the tool does with its parameters, what response the agent should expect, or how this differs from sibling tools. An agent has virtually no basis to invoke this tool correctly.

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

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

Schema description coverage is 100%, so the input schema already documents all 9 parameters. The main description adds nothing about parameters. Per the baseline rule, high schema coverage warrants a 3; the param descriptions themselves provide some useful context such as 'discarded after the shape check' and 'titles discarded', but that credit belongs to the schema, not the tool description.

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

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

The description is essentially a noun phrase restating the tool name: 'Short catalog of common HTTP status codes.' It does not state a specific verb plus resource, so an agent cannot tell whether the tool returns a list, performs a lookup, or validates a status code. It also does not distinguish the tool from siblings like fetch-status or web-fetch.

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

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

There is no guidance about when to use this tool or when to prefer an alternative. It never mentions sibling tools, exclusions, or the intended calling pattern, leaving the agent to guess based on the name alone.

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

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

With no annotations, the description carries the full burden. It does disclose one important behavioral trait: the prompt is discarded. However, it does not clarify side effects, whether any parameters are honored, what the returned template looks like, or how the 'discarded after the shape check' parameter descriptions relate to the tool's actual 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 very short and front-loaded, with no filler or repetition. Both sentences earn their place, though the extreme brevity leaves important 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?

Despite the apparent simplicity, the tool has 9 optional parameters, no annotations, and no output schema. The description is too sparse to tell an agent what to expect as output, why the parameters exist, or when this tool should be selected over the many siblings. It is minimally invocable but not adequately 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?

Schema coverage is 100%, so the baseline is 3. The description adds no per-parameter guidance and does not say which parameters, if any, affect the returned template. The phrase 'Prompt discarded' hints that input may be ignored, but this is not reconciled with the parameter descriptions that mention normalization, validation, and shape checks.

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

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

The description clearly states a specific action ('Return') and a specific resource ('a three-step thinking template'), and adds that the prompt is discarded. It does not fully explain what the template contains or distinguish itself from sibling tools, but the basic purpose 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?

There is no guidance about when to use this tool versus any of the many sibling tools. No exclusions, no alternatives, and no context about what kind of request should route to 'think-steps' rather than a shape-check or hint 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states what the tool returns and does not mention output format, side effects, or that most schema fields are ignored or 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, front-loaded sentence with no wasted words. It is concise, though it sacrifices usage and parameter detail for brevity.

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

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

With no annotations, no output schema, and a complex 9-parameter input, the one-sentence description is not sufficient. It does not identify the required input or clarify how the many unrelated schema properties are handled.

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

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

Although schema description coverage is 100%, the description offers no mapping from 'named IANA timezone' to any parameter. The visible schema parameters (ref, url, city, feed, host, json, path) are unrelated to timezone, so an agent cannot tell which field to populate.

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

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

The description names a specific verb and resource: it returns the current time for a named IANA timezone, which distinguishes it from sibling tools like utc-time and iana-zones. It is clear on intent, though it does not explicitly mention an example or alternative 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?

No guidance is given on when to use this tool instead of utc-time, iana-zones, or other siblings. The description implies a named timezone is needed but does not state exclusions or 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?

No annotations are present, so the description carries the full burden of behavioral disclosure. It reveals only the output and does not state whether the tool is side-effect-free, ignores inputs, makes network calls, or performs checks. The schema notes some values are 'discarded' and there is 'no disk access', but the description itself provides no such context.

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

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

The description is a single front-loaded sentence with no wasted words. It communicates the core purpose efficiently. However, it is terse relative to the complex input schema, though under-specification is better addressed under contextual completeness.

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 seven-parameter schema and no output schema, the description is far too thin. It does not clarify return format, whether arguments are needed, why the parameters exist, or any behavioral caveats. An agent would struggle to decide whether to call with no arguments, one argument, or several.

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 provides descriptions for all parameters, the parameters (ref, url, city, feed, host, json, path) are unrelated to a tool whose stated purpose is returning the current UTC timestamp. The description adds no explanation of whether these parameters affect the result or should be supplied. An agent cannot reliably infer correct parameter usage from the description alone.

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 resource and implied result: the current UTC timestamp. However, it does not use a specific verb ('returns', 'gets'), and it doesn't distinguish the tool from siblings like timezone or iana-zones. The seven-parameter input schema also sits in unexplained tension with the simple 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?

There is no guidance on when to use this tool versus timezone, iana-zones, or other siblings. The description only implies it is for obtaining the current UTC timestamp, but gives no exclusions, alternatives, or conditions. It also never clarifies that the listed parameters are optional or ignored for the timestamp result.

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 state that the body is discarded, which hints at no retention or side effects, but it never explains what happens on valid versus invalid JSON, whether the tool returns a boolean or throws, or any other runtime behavior. This is a meaningful gap given there is no output schema.

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

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

The description is two short sentences with the purpose front-loaded and no filler. The second sentence adds a real behavioral fact—the body is discarded—so both sentences earn their place.

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

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

Despite the apparently simple core purpose, the tool has nine optional parameters, no output schema, and no annotations. The description does not explain what result is returned, which parameter is the JSON body, or why the schema contains many seemingly unrelated fields. This is not complete enough for reliable autonomous invocation.

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

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

Schema description coverage is 100%, so the schema already documents all parameters, including the key one: 'JSON text to validate; discarded after the check.' The tool description adds no parameter-level meaning beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('check whether') and a specific resource ('a body is valid JSON'), so an agent can tell this is a JSON validity check rather than one of the sibling shape/URL validators. However, the term 'body' is not mapped to any parameter in the schema, which leaves minor 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?

The purpose statement implies when to use the tool: when you need to determine whether a JSON body is valid. It does not explicitly mention alternatives, exclusions, or prerequisites, but the intended use is reasonably inferable from 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?

No annotations are provided, so the description carries the behavioral disclosure burden. It mentions the Open-Meteo backend, which adds some context, but it does not state whether the operation is read-only, whether it makes network calls, whether non-city parameters are ignored, what limits exist, or what the response format is. The schema descriptions mention discarded parameters, but the tool description itself does not.

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 and places 'current temperature' first, making the core purpose immediately visible. It is appropriately brief, though it sacrifices useful context for brevity.

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

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

Despite the simple surface purpose, the tool has nine optional parameters and no output schema, and the description does not explain how they relate to the weather lookup. It also fails to mention that most parameters are discarded, what the response looks like, or why the tool accepts so many unrelated fields. An agent would likely be confused about how to invoke it correctly.

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

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

The input schema has 100% parameter description coverage, so the baseline is 3. The description adds no parameter meaning beyond what the schema already states, though it does imply that 'city' is the key parameter. This is sufficient given the schema's thoroughness.

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 function: returning current temperature for a city via Open-Meteo. It distinguishes this tool from siblings like geo-hint and lib-docs-hint by naming the weather domain, though it is phrased as a noun phrase rather than a full verb-driven sentence.

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. Sibling tools like geo-hint or web-fetch might overlap in purpose, but the description does not mention when weather-hint is the right choice, what inputs are required, or what to do if the city is not recognized.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal that the body is discarded, which is useful, but it omits all other behaviors: the tool accepts many unrelated input types (ref, city, feed, json, path), each with its own discard semantics, and it does not explain what happens for non-URL inputs. The description's narrow focus could mislead an agent into thinking the tool only handles URLs.

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

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

The description is very short and front-loaded, but it is under-specified for a tool with a complex seven-parameter schema. The two clauses are efficient, yet they omit essential information, making the brevity a drawback rather than a strength.

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

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

Given the tool has seven parameters, no annotations, and no output schema, the description is severely incomplete. It does not explain the purpose of the other parameters, the return format, error behavior, or which combinations are valid. A one-line description covering only one use case is inadequate for safe tool selection.

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 tool description only references 'public URL', while the schema contains seven parameters with detailed per-parameter descriptions. It adds no meaning for the six non-url parameters and actually conflicts with the schema's url description ('HTTPS URL to normalize or cite'), which suggests a different role than fetching status/content type. With low schema coverage and no compensating description, this is a significant gap.

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

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

The description names a concrete resource ('public URL') and a specific outcome ('HTTP status and content type'), with an explicit negative ('Body discarded'). This is a clear verb+resource statement. However, it does not mention the other input modes suggested by the schema (ref, city, feed, json, path), and could be confused with sibling fetch-status, though the addition of 'content type' provides some differentiation.

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

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

There is no guidance on when to use this tool versus siblings like fetch-status, browser-url-ok, or normalize-url. The description does not state conditions, exclusions, or alternative tools. An agent must infer usage from the name and the single URL-focused sentence.

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

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

No annotations are present, so the description carries the full burden. It discloses that the title is discarded after the call, a useful data-handling hint, but it omits whether the check is a network request or local validation, what the return value is, and whether there are 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 exceptionally concise, with two short sentences and no wasted words. It front-loads the core action, though the 'discarded' note is terse and somewhat puzzling.

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

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

With seven parameters, no annotations, and no output schema, a two-sentence description that fails to explain which parameter is the Wikipedia title leaves the agent unable to invoke the tool correctly. Return semantics and error behavior are also missing.

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

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

The description references a 'title' that does not exist in the input schema. The seven properties (ref, url, city, feed, host, json, path) all carry generic 'discarded after the shape check' descriptions, but none is identified as the Wikipedia title. The description adds no parameter guidance and actively conflicts with the schema's apparent behavior.

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: checking whether a Wikipedia title exists. This clearly differentiates it from sibling URL/file/domain validators. However, the schema contains no 'title' parameter, so the immediate usefulness of the clear purpose is undercut.

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 offers no guidance on when to use this tool versus sibling shape/ok checkers such as url-shape, domain-shape, or file-path-ok. No conditions, prerequisites, or exclusions are provided.

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