ISO country MA

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

With no annotations, the description carries the behavioral burden. It does disclose an important side-effect ('Task text discarded') and lists what is returned, which goes beyond the schema. However, it does not clarify cost, network side effects, authentication, persistence, or what 'remote MCP hops' means despite the 'pay-per-call' implication.

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: purpose, return contents, and a key behavioral caveat each get one sentence. There is no filler or repetition of schema 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?

Despite a high schema coverage, the tool is complex: nine optional parameters, no output schema, no annotations, and many siblings. The description does not explain how to invoke the tool meaningfully, what to do with the returned CLI setup/skill file/MCP hops, or why the parameters are accepted if most inputs are discarded. An agent would struggle to decide whether and how to call 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 only the global note that task text is discarded, without explaining how the nine optional parameters relate to each other or which should be supplied. It does not compensate for the absence of parameter-usage guidance, but the schema already documents each field individually.

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

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

The description uses a specific verb ('Find') and names a concrete resource ('public pay-per-call tool gateway (Monid)') plus what it returns. It is distinguishable from the sibling shape-check/hint tools, though 'Monid' is unexplained and the connection to the tool name 'agent-tool-index' is not made explicit.

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

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

There is no guidance about when to use this tool instead of a sibling, no exclusions, and no indication of what kind of query or input should trigger it. The only hint is the resource description, but an agent gets no decision rule for selecting this over similar discovery/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?

With no annotations, the description must disclose side effects and operational behavior. It only says no browser is launched; it does not state whether a network request is made, whether the URL is contacted, what happens on invalid input, or what the output indicates. This is a minimal safety disclosure 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 sentences with no wasted words; the first sentence states the action and the second clarifies a key behavioral constraint. It is shorter than ideal but structurally efficient.

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

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

The description is incomplete for an agent invocation: it does not specify the return type/meaning, which of the nine optional parameters to provide, whether the check is local or network-based, or how it differs from fetch-status and normalize-url. No output schema or annotations compensate, so an agent lacks enough context to call it reliably.

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?

Input schema covers all 9 parameters with descriptions, so the high-coverage baseline applies. The tool description itself adds no parameter-level detail and does not single out url as the operative input; however, schema descriptions do most of the work. A neutral score 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?

States a specific action ('check whether a URL can be opened') and a key negative behavior ('No browser is launched'), distinguishing it from browser-launching siblings like playwright-url-ok. However, 'can be opened' is not defined precisely (URL syntax/validity vs network reachability), leaving some ambiguity.

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

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

No explicit guidance on when to use browser-url-ok versus fetch-status, web-fetch, normalize-url, or playwright-url-ok. The phrase 'No browser is launched' implies a preference for cheap/static checks, but no when/when-not conditions are stated.

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

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

With no annotations, the description carries the full behavioral burden, but it only states 'Expression discarded.' This hints at non-persistence but does not clarify whether the tool returns a result, performs a side effect, or requires any specific input. The unrelated schema fields are left entirely unexplained.

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 with no wasted words, but the second sentence is ambiguous and the whole thing lacks connection to the large schema. It is concise in length but not in clarity, earning a middle 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?

Despite having 9 schema parameters and no output schema or annotations, the description fails to explain what inputs the tool accepts, what it returns, or why properties like host, json, and query exist. An agent cannot safely infer how to call this tool, making the description drastically incomplete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level detail and its 'a+b style' reference does not correspond to any property in the schema, so it neither helps nor harms the already self-sufficient parameter descriptions.

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

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

The description 'Evaluate a+b style arithmetic' essentially restates the calc-eval name without identifying which schema parameter carries the expression. It gives a generic verb and object but fails to map to any of the 9 unrelated properties, making it closer to a tautology than a usable purpose statement.

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

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

No guidance is provided on when to use this tool versus its many siblings, no explicit conditions, exclusions, or alternatives. The only implied context is arithmetic evaluation, which is not enough for an agent to decide between calc-eval and other 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 behavioral burden. It adds the useful privacy-related trait that page content is not stored, implying a non-retaining read operation. Still, it does not disclose details such as whether the URL is fetched live, how redirects or errors are handled, or what happens to the other schema parameters.

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

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

The description is two short sentences that front-load the core purpose and add a useful caveat. Every sentence earns its place, and there is no redundant or vague filler.

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

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

Despite being concise, the tool has nine parameters, no output schema, no annotations, and many closely related sibling tools. The description does not clarify how to handle the extra parameters or what the exact return shape looks like, leaving an agent uncertain about 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?

Schema description coverage is 100%, so the baseline applies. The description adds minimal parameter-specific meaning beyond identifying URL as the core input; the many discardable parameters are only explained inside the schema itself.

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 operation: return host, scheme, and HTTP status for a URL. It is specific about the resource and output, and the 'page content is not stored' caveat adds useful distinction from content-fetching tools. However, it does not explicitly differentiate from URL-focused siblings like fetch-status or normalize-url.

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

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

No guidance is given about when to use this tool versus alternatives, and the description does not mention exclusions or prerequisites. The only hint is 'for a URL', which is too weak to route an agent among many similar 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 provided, the description carries the full behavioral burden. It does disclose that identifiers are not retained, which is useful, but it does not say whether the operation is read-only, what side effects exist, what happens to the provided inputs, or what the output looks like. The schema-level 'discarded' notes are outside the tool description itself.

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

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

The description is compact and front-loaded, with the core purpose stated before the privacy note. Both sentences are short and avoid unnecessary detail, though the first sentence is vague enough to limit its usefulness.

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

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

For a tool with nine optional parameters, no required parameters, no output schema, and a large cluster of similar siblings, this description is incomplete. An agent cannot determine what to pass, what the classification result will be, or when this tool is preferable to alternatives.

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 the meaning of all nine optional parameters. The tool description adds no parameter-level guidance and does not clarify which, if any, parameters should be provided 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 states a clear verb and object ('Show how this request is classified'), but it never explains what 'classified' means, what categories exist, or how the tool relates to its many similar siblings. This is more than a tautology, but too vague for an agent to reliably know what this tool 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?

There is no guidance on when to use this tool instead of the many sibling tools with overlapping input shapes (URLs, refs, paths, timezones, queries). The privacy note is not a usage guideline, and no alternatives or exclusions are mentioned.

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

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

With no annotations, the description carries the behavioral disclosure burden. It does disclose that the tool returns no WHOIS/ownership data, and the parameter descriptions add that inputs are discarded after checks and no disk access occurs. However, it does not clarify the output format, error behavior, or which parameters actually drive the call, so transparency is only partial.

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

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

The description is a single efficient sentence that front-loads the verb and resource and avoids filler. It loses one point because it omits any hint about the surprising multi-parameter schema, making the conciseness less useful than it could be.

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

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

The tool has nine optional parameters, no required fields, no output schema, and no annotations, so the description must do more to specify how to invoke it. It does not state that 'host' is the operative parameter, what happens to the other fields, or what the returned labels look like. An agent cannot confidently call this tool correctly from the provided information.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does reinforce that 'host' is the meaningful field for a hostname, but it does not explain why the other eight unrelated fields exist or whether they are ignored. It adds little beyond the schema's own parameter descriptions.

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

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

The description states a specific verb and resource: 'Split a hostname into labels', and adds a meaningful scope qualifier: 'without WHOIS or ownership data'. This makes the core purpose clear and distinguishes it from ownership-related lookups. However, the input schema accepts nine unrelated optional fields, which muddies exactly what the tool operates on.

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 over sibling tools such as normalize-url, browser-url-ok, or github-repo-shape. The only hint is the negative qualifier about WHOIS/ownership data, which implies a boundary but names no alternative or selection condition.

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 behavioral disclosure burden. It does disclose the HTTP method (HEAD), scope (public URL), and result granularity (status only), which are useful. But it omits behavior on redirects, timeouts, invalid URLs, and what happens with the many other accepted parameters, so transparency is partial.

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

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

One short sentence, front-loaded with the action and outcome. Every word earns its place, and there is no redundant restatement of the tool name or schema.

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

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

The tool has 9 optional parameters, no required parameters, no output schema, and no annotations, making it relatively complex. The single-sentence description does not explain which parameters are actually used, what the status response looks like, or how errors are surfaced, so an agent cannot reliably invoke it in non-trivial 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 schema already documents all nine parameters, earning a baseline of 3. The description adds meaning only for the URL input, but does not name the parameter or clarify that the other eight parameters are irrelevant to this tool, which is a moderate gap given the schema's breadth.

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 (HEAD), a resource (public URL), and the exact output (status only). This clearly differentiates it from content-fetching siblings like web-fetch and browser-based checkers like browser-url-ok, without relying on the tool name alone.

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

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

The description implies when to use it: when you need only the HTTP status of a public URL. However, it names no alternatives, gives no when-not-to-use conditions, and does not explicitly route the agent away from web-fetch or playwright-url-ok, leaving usage guidance largely inferred.

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

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

With no annotations, the description must carry the full behavioral burden, but it only says 'Path discarded.' It does not state whether the URL is fetched, validated, normalized, or what the return value is, nor does it explain the discard behavior for the other eight 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 two short sentences with no filler and front-loads the main action. However, 'Path discarded' is cryptic and, combined with the mismatched schema, brevity comes at the cost of 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 9-parameter tool with no output schema and no annotations, the description is far too incomplete. It omits the return shape, which parameter(s) to send, whether non-URL inputs are valid, and how the unrelated schema properties relate to Figma URL parsing.

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% and each property already has a description, so the baseline is met. The description adds no real parameter semantics beyond clarifying that the url is a Figma file URL, while the schema itself is generic (HTTPS URL to 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 names a specific action and resource: 'Parse a Figma file URL'. However, the input schema accepts nine unrelated strings (city, json, zone, query, etc.), so the stated scope conflicts with the actual tool signature and leaves the real purpose 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?

There is no guidance on when to use this tool versus normalize-url, domain-shape, github-repo-shape, or other URL/shape siblings. The name implies Figma-only use, but the broad schema suggests a more general shape check, giving an agent conflicting selection signals.

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 behavioral disclosure burden. 'No disk access' is a useful, non-obvious behavioral guarantee, but the description does not explain what 'safe' means, whether it returns a boolean, or what edge cases it handles.

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. Both sentences earn their place: one states the core purpose, and the other gives a critical non-obvious safety guarantee.

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

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

Despite having 9 parameters, no annotations, and no output schema, the description does not specify return values, what 'safe' means, or how to select among the many schema fields. The odd breadth of the input schema makes this thinness more costly, as an agent could easily pass the wrong parameter.

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

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

Schema description coverage is 100%, so the parameter schemas themselves document each field. The tool description adds minimal parameter meaning, only implying that the `path` parameter is the relevant one, which is already clear from 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 a specific action ('Check whether a path looks safe') and the resource ('a path'), and the 'No disk access' note adds useful scope. It does not explicitly differentiate from sibling tools like normalize-url or wiki-title-ok, but the file-path focus is apparent from the name and wording.

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, nor any exclusions or prerequisites. An agent must infer that this is the right choice for local/string-based path safety checks rather than URL or network-validating 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only reveals that the lookup happens via Open-Meteo; it does not mention network dependency, error behavior, side effects, or that most input fields 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 front-loaded sentence with no filler and every word contributes. It loses a point because it is a noun phrase rather than an explicit instruction, leaving the verb 'returns' implicit.

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

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

Given no annotations, no output schema, and nine parameters, the one-sentence description is insufficient. It does not explain which parameter identifies the place, what the output format is, what happens on failure, or how this tool relates to the many sibling tools.

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

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

Schema description coverage is 100%, so the baseline is 3 even without parameter details in the tool description. The description adds little beyond 'a place,' and the agent must infer that city is the relevant parameter while the other eight optional fields are unrelated to the coordinate lookup.

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

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

The description states a clear function: return latitude and longitude for a place, with Open-Meteo as the provider. It is specific enough to distinguish this from sibling tools like weather-hint or timezone, though it lacks an explicit verb and does not name alternatives.

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

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

No usage guidance is provided. The description does not say when to prefer geo-hint over other tools, what kind of place input is expected, or whether only the city parameter is relevant. The intended usage is only implied by the purpose statement.

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 clearly implies a read-only parse and names the extracted values, but it does not describe behavior for invalid or non-GitHub URLs, whether other supplied fields are ignored, or what the return shape looks like. For a pure parse tool, this is a moderate gap rather than a severe one.

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 and no repetition of schema information. Every word contributes to the core 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?

For a narrow parse tool, the description plus the schema is minimally viable: an agent can infer that it should pass a GitHub URL. However, with no output schema and no annotations, the description omits the return contract and invalid-input behavior, which leaves some uncertainty for an agent choosing and invoking the tool.

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

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

The schema already documents all parameters (100% coverage), so the baseline is 3. The description adds the useful constraint that the URL should be a GitHub URL and that owner/repo are the intended outputs, but it does not clarify which of the many optional parameters to provide or that most 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?

The description clearly states the tool's action ('Parse'), the resource being parsed ('owner and repo'), and the input scope ('from a GitHub URL'). It is unambiguous and can be distinguished from sibling shape tools like figma-url-shape or jira-key-shape without opening 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 description gives no when-to-use or when-not-to-use guidance. It does not mention alternatives such as normalize-url or browser-url-ok, nor does it clarify the condition that should lead an agent to select this tool over others.

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 transparency burden. It discloses that titles are discarded and that the count is 'current,' but it does not mention network behavior, caching, error cases, or whether any side effects occur. This is adequate but minimal for a simple read-only count 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 main action is front-loaded, and the 'Titles discarded' note is a useful, concise qualifier.

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 counting tool, the description conveys the main purpose and output scope. However, with no output schema and no annotations, it does not explicitly describe the return value format, failure behavior, or the role of the many optional parameters, so an agent still has minor gaps to bridge.

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 for all nine parameters, so the description need not restate them. However, the description does not clarify whether any of these optional parameters actually affect the HN count or are irrelevant, leaving some ambiguity about 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 description states a specific verb ('Count'), a specific resource ('current Hacker News front-page stories'), and clarifies output scope with 'Titles discarded.' This is immediately distinguishable from the sibling fetch, status, and 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 implies when to use the tool: when a count of current HN front-page stories is needed. It does not explicitly name alternatives or state when not to use it, but the context is reasonably clear from the wording.

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. The description only states that the tool provides common names; it does not disclose the return format, whether it performs checks, or why parameters are described as 'discarded' or used for 'shape check.' The behavioral aspects are essentially 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 concise sentence with no redundancy. However, it is under-specified for a tool with nine parameters and no annotations. The brevity here reflects omission rather than disciplined conciseness, leaving the agent without essential operational detail.

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

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

Given the confusing parameter list, missing annotations, and no output schema, the description is far from complete. It does not explain what the tool returns, how to invoke it with or without arguments, or why the declared parameters exist. An agent cannot reliably select and call this tool correctly based on the provided definition.

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

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

Although schema coverage is 100%, the parameter descriptions are unrelated to the stated purpose—ref is a Git ref, url is a URL to normalize, json is text to validate, etc. None of the nine parameters is a timezone name, and the description does not explain how to request an IANA zone. This is a case where coverage exists but the semantics are misleading, so the baseline 3 cannot be sustained.

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 IANA timezone names for clock calls,' which conveys the domain and some relationship to time-related tools. However, it lacks a clear verb or operation—it does not say whether the tool lists, validates, or resolves these names. It offers only weak differentiation from sibling tools like 'timezone' and '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' hints at a context, but there is no explicit guidance about when to use this tool versus alternatives. It does not name sibling tools like 'timezone' or 'utc-time' as alternatives, nor does it state any exclusions or prerequisites. An agent would have to guess when this tool is the right choice.

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

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

With no annotations provided, the description must carry the behavioral disclosure burden. It does convey that the operation is a public network read and that only group counts are returned rather than the full robots.txt content. However, it does not mention error handling, missing robots.txt behavior, redirects, or rate limiting, so transparency is only partial.

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

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

The description is a single front-loaded sentence with no wasted words. It states the action, target resource, and output scope efficiently.

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

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

For a tool with 9 optional parameters, no output schema, and no annotations, the description is too sparse to fully support correct invocation. It omits which parameter is required, what the group-count result looks like, and how errors are surfaced.

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 generic and appear reused from unrelated tools, such as 'HTTPS URL to normalize or cite' and 'Git ref name; discarded after the shape check.' The tool description does not explain which parameter provides the robots.txt target, and all parameters are optional, making correct invocation ambiguous.

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

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

The description states a specific verb and resource: 'Fetch a public robots.txt' and restricts the output to 'group counts only.' This clearly differentiates it from siblings like web-fetch, fetch-status, and domain-shape, and matches the tool name.

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

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

The description says what the tool does but gives no guidance on when to prefer it over alternatives, when not to use it, or what prerequisites it needs. It does not name a sibling tool or exclusion condition, so an agent is left 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?

No annotations are present, so the description carries the burden of behavioral disclosure. The phrase 'Key discarded' explicitly states that the key is not retained, which is a genuine behavioral note. However, it does not describe return value, side effects, or error 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-loads the purpose in the first sentence. However, 'Key discarded' adds little actionable information and the brevity hides critical details about inputs and expected results.

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 eight parameters, no output schema, and no annotations, the description is severely incomplete. It omits which input carries the Jira key, what a valid shape is, what the check returns, and how it differs from other shape-validation tools.

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

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

Although every schema parameter has a description, the tool description never identifies which parameter is the Jira key or how the key should be supplied. None of the parameters are named 'key,' and the schema descriptions are generic, so the agent cannot map the described concept to the actual inputs.

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 object: 'Check a Jira issue key shape.' This clearly distinguishes it from sibling shape-checking tools like github-repo-shape or domain-shape. The trailing 'Key discarded' is confusing but does not obscure the core purpose.

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

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

There is no guidance about when to use this tool versus alternatives such as github-repo-shape or figma-url-shape. The intended use is only implied by the tool name and first sentence, with no exclusions or prerequisites stated.

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

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

No annotations are present, so the description carries the full burden. It discloses that the body is discarded, but does not explain output format, redirect handling, error behavior, or that most schema parameters are irrelevant for this tool.

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

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

The description is two short sentences with no wasted words and front-loads the core action. It is concise, though arguably under-specified for a tool with nine optional parameters.

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

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

With no output schema and no annotations, the description must explain what the agent should pass and what it will receive. It only says 'HTTP status' and 'Body discarded,' leaving the parameter selection and return shape largely unspecified.

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 insight and does not clarify whether only 'url' matters or how the other optional fields should be handled.

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: return the HTTP status for a public library docs URL and discard the body. This is more specific than generic status tools, though the 9-parameter schema with city, feed, json, and other unrelated fields makes the actual scope somewhat confusing.

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

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

There is no guidance about when to use this tool versus siblings like fetch-status, normalize-url, or domain-shape. The description implies a narrow use case but gives no exclusions or decision 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 must carry the behavioral transparency burden. It discloses one behavior—'Values discarded'—but does not state side effects, return behavior, error handling, or whether the input JSON is modified. This is minimal transparency for a tool with no annotation support.

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

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

The description is two short sentences with no filler: 'Count keys in a JSON object. Values discarded.' It front-loads the action and object and earns each word. Even though it is incomplete in other dimensions, it is appropriately concise.

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

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

There is no output schema and no annotation context, but the description does not state what is returned, how keys are counted (top-level only vs. nested), which parameter to provide, or how malformed JSON is handled. With nine optional parameters, this is a significant completeness 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 the baseline is 3 even though the description itself adds little parameter meaning. However, the description never links 'JSON object' to a specific parameter, and the schema's `json` parameter says 'JSON text to validate' rather than 'JSON text to count keys from,' creating ambiguity. The high coverage prevents a lower score, but better linkage would have made this clearer.

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

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

The description states a specific action and resource: 'Count keys in a JSON object.' This is distinct from the sibling validate-json tool, which is about validity checking rather than counting. It is slightly weaker for not clarifying whether the JSON is supplied via the `json` parameter or is some internal/memory object, but the core purpose is clear.

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

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

The description gives no explicit when-to-use guidance and does not mention alternatives such as validate-json for validation or search-query-len for counting query length. It also does not say which of the many optional parameters should be supplied, leaving the agent to guess how to invoke the tool. Any usage context is only weakly implied by the name and one-line description.

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

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

With no annotations available, the description carries the disclosure burden. It openly reveals that query and fragment are discarded and that only origin, host, and path are returned. It does not mention error behavior or normalization details, but the main lossy behavior is clearly disclosed.

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 tight sentences with no filler. It front-loads the primary output and then adds the key exclusion behavior, making it 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?

The core behavior is clear, but the schema is noisy with nine optional parameters and no required fields. The description does not explicitly tell the agent that only `url` should be supplied, nor what happens with invalid or non-HTTPS URLs, leaving some ambiguity 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?

Schema description coverage is 100%, so the schema already documents all parameters. The description adds no extra parameter-level guidance, such as clarifying that only the `url` parameter is relevant or that the other parameters are ignored, even though some schema descriptions hint at being discarded.

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

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

The description clearly states what the tool does: return origin, host, and path for a URL. It also specifies that query and fragment are dropped, making the tool's behavior distinct from sibling URL-checking or shape-validation 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 purpose statement gives clear context for when to use the tool: when normalized URL components are needed. It does not explicitly name alternatives or state when not to use it, so it stops short of a perfect score.

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 discloses one behavioral fact: no browser is launched. It does not state whether the tool performs a network request, validates syntax, returns a boolean, requires authentication, or what side effects may 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 very short and front-loads the central action, with no filler. However, given the nine optional parameters and sibling ambiguity, the brevity is borderline under-specification rather than ideal concision.

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 mention of return values, typical call patterns, or why the many optional parameters exist. For a 9-parameter tool with many closely named siblings, this description is not complete enough for an agent to select and 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 input schema already documents each of the nine parameters. The tool description adds no parameter behavior or relationships, leaving the schema to do the work; baseline 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 gives a specific action ('Check') and object ('whether a URL can be opened'), so the core purpose is clear. It does not, however, explain how this differs from closely related siblings such as browser-url-ok or fetch-status, and 'opened' is ambiguous without more detail.

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

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

No guidance is provided about when to prefer this tool over browser-url-ok, fetch-status, normalize-url, or other siblings. The caveat 'No browser is launched' hints at a lightweight check but stops short of saying when it should or should not 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?

With no annotations available, the description carries the full burden of disclosing behavior. 'Query discarded' does add a useful side-effect note. But the description does not explain whether the other eight schema parameters are ignored, rejected, or relevant, nor does it clarify the exact return value. This unaddressed mismatch between the narrow description and the broad schema is a significant behavioral gap.

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

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

The description is two very short sentences with the action verb front-loaded and no filler. 'Query discarded' earns its place by disclosing a side-effect/privacy property. This is appropriately sized for a simple counting tool.

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

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

Despite a simple core operation, the tool exposes nine optional parameters, has no annotations, and has no output schema. The description does not explain the role of the extra parameters, whether they are ignored, or what the return type is. An agent reading only this definition cannot confidently predict the full behavior of a call.

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

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

Schema description coverage is 100%, so the baseline is 3; each parameter already has its own description. The text naming a 'search query' maps clearly to the query parameter, but it adds no new meaning beyond the schema. It also fails to help disambiguate why so many unrelated parameters are present.

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 ('Count') and object ('characters in a search query'), which clearly matches the tool name and distinguishes it from sibling counters by the search-query focus. It is not a tautology and is understandable. However, it does not explicitly address the large set of unrelated parameters in the schema, which slightly weakens purpose 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?

The purpose statement implies the usage: call this when you need the character length of a search query. It does not mention alternatives, exclusions, or when not to use it, and it never relates the tool to sibling tools like validate-json or normalize-url. The guidance is implicit rather than explicit.

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

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

With no annotations, the description bears the full burden of behavioral disclosure, and it only says this is a catalog. It does not state whether the call is read-only, whether parameters are ignored or discarded, or what the response looks like. The input schema even hints that many inputs are discarded after checks, but the description does not confirm this behavior.

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

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

The description is a single short noun phrase with no filler, and the label 'short' is up front. It is concise, but it is concise to the point of under-specification.

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 10 optional parameters, no output schema, and no annotations, this description provides almost none of the context an agent needs to call it correctly. It does not explain what output to expect, which parameter to use, or how it relates to the sibling tools.

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

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

The description contributes no parameter meaning, but the input schema already documents all 10 parameters with descriptions, so the baseline is 3. Those schema descriptions are internally informative (e.g., 'discarded after the shape check'), though their relationship to a 'catalog of HTTP status codes' remains unclear.

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 tool as a catalog/reference of common HTTP status codes, which is more than a tautology and gives some sense of purpose. However, it lacks an action verb and does not clarify how this differs from siblings like fetch-status, which likely perform live status fetches.

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 indication of when to use this tool instead of alternatives, no mention of fetch-status or other sibling tools, and no conditions or exclusions. The only implied usage is looking up common codes, but that is left entirely to inference.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does disclose a key trait: 'Prompt discarded.' However, it does not describe what happens to the other inputs, what the template actually contains, or whether any side effects exist.

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

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

The description is very short and front-loaded, with no filler. Both sentences earn their place, though the extreme brevity leaves some behavioral and contextual gaps.

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

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

Despite having 9 optional parameters and no output schema, the description does not explain how the inputs relate to the returned template, what the template looks like, or why the prompt is discarded. The parameter descriptions in the schema help but do not compensate for the missing tool-level context.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The tool description adds no parameter-level meaning beyond that, so the baseline score of 3 applies.

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

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

The description states a clear action and resource: 'Return a three-step thinking template.' It is not a tautology and is distinct from the sibling validation tools, though it does not explicitly name any sibling alternatives.

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

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

The description gives no guidance on when to use this tool versus any alternative. 'Prompt discarded' hints at a limitation, but there is no explicit context about the intended use case 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?

No annotations are provided, so the description carries the full burden, yet it discloses almost no behavioral context: it doesn't state that the many other input fields are ignored/decoy, how an invalid or missing zone is handled, or what the returned time looks like. 'Current time' implies a read, but not enough for a tool with 9 optional unrelated 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?

A single front-loaded sentence with no filler; every word earns its place in stating the core 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?

For a simple read-only time lookup the minimal description is nearly adequate, and the schema fills in the zone parameter. However, given the unusual schema with nine unrelated optional fields and no output schema or annotations, the definition should clarify which input actually matters and what the caller receives.

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

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

Schema description coverage is 100%, including the zone parameter description ('IANA timezone name, e.g. Europe/Paris'), so the schema already carries the parameter meaning. The description reinforces that the relevant input is a named IANA timezone but adds no new format or value constraints.

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

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

The description clearly identifies the resource as a named IANA timezone and the desired output as the current time, which distinguishes it from sibling tools like iana-zones (zone listing) and utc-time (UTC). It lacks an explicit verb, but the intent is unambiguous.

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

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

The phrasing implies using this tool when a caller wants the current time in a specific IANA timezone, and the sibling list suggests alternatives, but the description itself gives no explicit when/when-not guidance or named 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 behavioral burden, but it only says 'Current UTC timestamp.' It does not disclose the output format, precision, or that the many input schema parameters are explicitly ignored or discarded. This leaves the agent confused about why a timestamp tool accepts ref, url, city, and other unrelated fields.

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 and front-loaded, with no filler or redundant phrasing. It earns conciseness, though the terseness comes at the cost of omitted behavioral detail penalized in other dimensions.

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

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

For a tool with no output schema and no annotations, this description is too minimal. The presence of seven seemingly unrelated schema parameters without any explanation of why they exist, combined with no format details for the timestamp, makes the description incomplete for reliable invocation.

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

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

The input schema itself provides descriptions for every parameter, including stating that each is discarded after a shape check, so schema coverage is effectively 100%. The tool description adds no parameter-level meaning, but the baseline of 3 applies because the schema already handles this dimension.

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

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

The description clearly states that the tool returns the current UTC timestamp, which is a specific and unambiguous value. It does not explicitly differentiate itself from sibling tools like timezone or iana-zones, but the meaning is still 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 siblings such as timezone or iana-zones. No context is given about expected input dependencies or what kind of requests should be routed here.

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 says 'the body is discarded,' which discloses an important non-retention behavior. Since no annotations are provided, this helps but does not fully cover other behavioral aspects such as return behavior, side effects, or error handling.

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

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

The description is extremely concise: two short sentences with no filler. The core purpose is front-loaded, and the behavioral note about discarding earns its place.

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

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

The tool has no annotations and no output schema, so the description should explain enough about the call contract, including what is returned. It does not state the output format or how validity is reported, leaving an important gap for an agent that needs to act on the result.

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

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

The input schema already provides descriptions for all parameters, including 'JSON text to validate.' The description adds no additional parameter-level meaning beyond what the schema communicates, 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 clearly states the tool validates whether a body is valid JSON, with a specific verb and resource. It does not explicitly distinguish itself from the sibling shape-validation tools, but the focus on JSON is enough to make the core purpose unambiguous.

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

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

The intended use is implied: call this tool when you need to check whether a body or JSON text is valid JSON. However, there is no explicit guidance about when not to use it or which alternative tool to prefer, so the usage guidance is only implicit.

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

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

With no annotations, the description carries the full burden of behavioral transparency. It states the core lookup behavior and data source, but does not disclose that this is a live network read, which parameter is actually used, what units are returned, or what happens when multiple parameters are supplied. The unusual 9-parameter schema makes this lack of detail more significant.

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 compact sentence that immediately states the operation and the data source. There is no filler or redundancy, 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 has 9 optional parameters, no required parameters, no output schema, and no annotations. The description does not clarify which parameter is needed, what the response looks like, or whether the other parameters are ignored. For an agent to invoke this correctly, more context is required.

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 essentially no parameter meaning beyond 'city', and the schema already describes every parameter including the 'discarded after the call' behavior for several fields. The description does not compensate for the potentially confusing array of unrelated parameters.

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

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

The description clearly identifies the operation: returning a current temperature for a city, and names the data source (Open-Meteo). It is not a tautology and is distinguishable from siblings like geo-hint or timezone, though it could be more explicit with a verb like 'Get'.

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

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

No guidance is provided about when to use this tool versus alternatives such as geo-hint, web-fetch, or other hint tools. There are no conditions, exclusions, or indications of which sibling tools are not appropriate.

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

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

With no annotations, the description carries the full behavioral burden. It clearly discloses that the body is discarded and indicates the two return fields (HTTP status, content type). It does not mention redirects, error handling, or how the other eight schema parameters relate to the fetch, leaving ambiguity.

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

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

Two sentences with no filler; the core function is front-loaded and the secondary behavior ('Body discarded') is stated separately. Every word earns its place.

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

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

The tool has 9 optional parameters, no annotations, and no output schema, yet the description only covers URL fetching. It does not clarify whether `url` is required, what the other parameters do, or how this tool relates to sibling status-check tools, so an agent cannot confidently invoke it in all intended 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 coverage is 100%, so the baseline is 3. The description reinforces that `url` is the key input by mentioning 'a public URL', but it adds no detail about the other parameters or which are applicable, and the schema marks none as required.

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

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

The description states the tool returns HTTP status and content type for a public URL and explicitly notes the body is discarded. This is a specific and understandable outcome, though it lacks a verb and does not differentiate from sibling tools like fetch-status or browser-url-ok.

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

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

The description scopes usage to 'public URL' and warns 'Body discarded', implying it should be used when only status and content type are needed. However, it does not name alternatives or provide when-not-to-use guidance, leaving selection among siblings to inference.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does add one useful behavioral trait: 'Title discarded after the call,' which communicates statelessness/privacy. However, it does not mention the return value, whether a network request is made, failure behavior, or whether this is an existence check versus a shape validation.

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 extremely short and front-loaded, with no wasted words. But two sentences are not appropriately sized for a tool with seven unrelated schema parameters and no output schema; under-specification is not the same as 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?

This definition is nearly useless for correct invocation: seven schema parameters with no connection to the stated purpose, no annotations, no output schema, and no usage context. The gap between the description and the structured fields is severe, leaving the agent unable to infer what to pass or what to expect.

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

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

The description says nothing about how to map any schema parameter to the Wikipedia title being checked. The schema lists seven parameters (ref, url, city, feed, host, json, path), none of which plausibly corresponds to a title, and their descriptions reference unrelated 'shape check' semantics. An agent cannot determine which input to supply.

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

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

The first sentence states a specific verb and resource: 'Check whether a Wikipedia title exists.' This is a clear, recognizable purpose that differentiates it from sibling tools like normalize-url or validate-json. However, the input schema contains no 'title' parameter, so the stated purpose does not align with any actual field, leaving the tool's real scope 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 provides no guidance on when to use this tool versus alternatives. It neither names related tools nor gives conditions or exclusions. An agent is left to infer that this is a niche check among many shape/existence tools.

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