ISO country MZ

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

With no annotations, the description carries the behavioral disclosure burden. It usefully states that task text is discarded and that the tool returns CLI setup, a skill file, and MCP hops, but it does not mention side effects, network behavior, cost implications, or output format.

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 sentences, front-loaded with the purpose and deliverables, with no filler. Each sentence earns its place.

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

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

For a tool with zero required parameters, it covers purpose, return artifacts, and a privacy note. But with no output schema and nine optional parameters whose roles are unclear, the description is only minimally sufficient 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 coverage is 100%, so the baseline is 3; the description adds no parameter-level information. It also does not clarify whether any of the optional 'discarded' parameters are ever meaningful.

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 ('Find') and resource ('public pay-per-call tool gateway (Monid)') and lists the returned artifacts, which distinguishes it from the sibling shape-check and fetch tools. However, 'Monid' is left unexplained and no explicit contrast with sibling tools is given.

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 use case is implied: call this when you need the Monid gateway's CLI setup, skill file, or MCP hops. There is no explicit when-to-use or when-not-to-use guidance, and no alternative tools are named among the 27 siblings.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does add one useful behavior: 'No browser is launched.' However, it does not explain what 'can be opened' means, whether a network request is made, what side effects or permissions may apply, or what the tool actually does to determine the result.

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

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

The description is only two sentences and every word earns its place. The main claim is front-loaded, and the clarifying negative behavior follows immediately. There is no redundancy or filler.

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

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

The tool has nine optional parameters, no output schema, and no annotations, but the description provides almost no context for how to invoke it correctly. It does not state what the result looks like, which parameters are relevant, or how to distinguish this from several similar siblings. This is a significant completeness gap for an agent.

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

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

Schema description coverage is 100%, so each parameter already has an explanation in the schema. The tool description itself adds no parameter-level meaning, which is acceptable under the baseline, but it also does not reconcile the URL-check purpose with the many heterogeneous optional properties.

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

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

The description states a specific action and resource: 'Check whether a URL can be opened.' It also clarifies a likely misconception with 'No browser is launched,' which helps distinguish it from browser-launching siblings. However, it does not explicitly name or contrast a sibling tool, so it stops short of full differentiation.

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

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

The phrase 'No browser is launched' implies this is appropriate when a lightweight, non-browser URL check is desired, and it hints at an alternative like playwright-url-ok. But there is no explicit when-to-use, when-not-to-use, or alternative tool guidance, leaving the agent to infer the intended 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 must disclose behavior itself. The only behavioral trait stated is that the expression is discarded, but the description says nothing about return values, error handling, side effects, or auth. Worse, the schema's per-field 'discarded after...' notes suggest a different generic discard behavior, and the expression input is never located.

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 the core verb is front-loaded. However, extreme brevity borders on under-specification, which slightly lowers the score.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, a six-word description does not enable correct invocation. It lacks the input-to-expression mapping, return format, and any details about how the expression is 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 coverage is 100%, so the schema documents each field, but the description adds no mapping from 'a+b' to any of the nine parameters. Since all parameters are optional and no expression field exists, an agent cannot determine what to pass for arithmetic evaluation.

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

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

The description names a specific operation, evaluating a+b arithmetic, and notes the expression is discarded. However, the input schema contains no expression parameter—only ref, url, city, feed, host, json, path, zone, and query—so the stated purpose does not map to any caller-visible input. This makes the purpose misleading for an agent trying to invoke the tool.

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

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

The description implies the tool is for arithmetic evaluation but gives no guidance on when to choose calc-eval over siblings such as validate-json or search-query-len. It also provides no exclusions, prerequisites, or situational 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?

With no annotations, the description carries the full behavioral burden. It adds a useful privacy-related disclosure, 'Page content is not stored', but it does not mention network behavior, side effects, error handling, or any authentication requirements.

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 concise sentences with no fluff. The main behavior is front-loaded, and the privacy note adds useful distinction without unnecessary length.

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 output schema, and no annotations, the description is thin. It covers the return fields for a URL but leaves the role of the other parameters and selection context ambiguous, even though the schema descriptions help somewhat.

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 little beyond the schema, simply referring to 'a URL' while the schema documents many extra parameters like ref, city, feed, and json. It does not explain how or whether these parameters participate in the citation 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: it returns host, scheme, and HTTP status for a URL. It is clear about the core output, though it does not explicitly distinguish itself from sibling tools 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?

There is no guidance on when to use this tool versus alternatives. It does not mention any exclusions, prerequisites, or conditions that would help an agent choose citation over similar URL-related 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 behavioral burden. It usefully states that no identifiers are retained, and the per-parameter schema descriptions reinforce that inputs are discarded. However, it does not disclose whether the tool is read-only, whether it calls external services, or what side effects occur during classification.

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

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

The description is short, front-loaded, and contains no filler; both sentences add information. It loses one point because the lead sentence is vague enough that the compactness reads as under-specification rather than efficient 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?

There is no output schema and no annotations, so the description must explain what classification result an agent should expect and how the parameters map to that result. It does neither, leaving an agent unable to predict return values or fully judge when the tool applies.

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

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

The schema has 100% parameter description coverage, with each of the nine parameters explaining its purpose and discard behavior. The tool description adds no 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 names an action (show classification) and a resource (the request), so it is not a tautology. However, it never explains what classifications exist, what the output looks like, or what the nine input parameters have to do with the classification, and it does not distinguish this tool from its many siblings.

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

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

There is no guidance about when to use this tool versus siblings like validate-json, timezone, normalize-url, or file-path-ok. No conditions, prerequisites, or exclusions are provided, so an agent cannot determine when compatibility is the appropriate 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states a negative constraint—no WHOIS/ownership data—and gives no information about side effects, return format, error behavior, or whether the input is transformed or discarded. For an unannotated tool, this is insufficient.

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

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

The description is a single, front-loaded sentence with no wasted words. It states the core operation and an important limitation efficiently. It is concise, though slightly too terse to cover the tool's actual complexity.

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

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

The tool has nine optional parameters and no output schema, yet the description only covers the hostname scenario. It does not explain what the tool returns, why other parameters exist, or how to choose among them. This leaves significant context missing for an agent deciding whether and how to invoke the tool.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds only a hint that 'hostname' relates to the host parameter, but it does not explain the nine-parameter superset or add format-level detail beyond the schema. This matches the baseline for high schema coverage.

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

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

The description states a specific verb and resource: split a hostname into labels. It also adds a meaningful delimitation—'without WHOIS or ownership data'—which distinguishes it from ownership-oriented tools. However, it does not mention the broader 'shape' validation nature of the tool or the fact that the input schema contains many unrelated 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?

No explicit guidance is given for when to use this tool versus alternatives. The phrase 'without WHOIS or ownership data' implies it is not for ownership lookups, but no sibling tool or contrasting use case is named. An agent is left to infer 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, the description must carry the behavioral burden. It discloses the method (HEAD) and that only status is returned, but it does not explain behavior for non-URL parameters, what 'status' means, error handling, redirects, or whether inputs are discarded. The schema hints at shape-check/discard behavior, so the description under-reports.

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

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

The description is one tight sentence with no filler and front-loads the core operation. It is concise, though too sparse relative to the nine-parameter schema, which is why it is not a 5.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, the description is incomplete: it omits the multi-parameter nature, return value shape, usage caveats, and relationship to the many siblings. An agent would not know how to invoke it for JSON validation, weather hints, or timezone checks based on 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 each parameter has its own description and the baseline is 3. The tool description adds no meaning beyond 'public URL' and does not clarify whether parameters are alternatives or combined, but the schema already provides adequate individual 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 states a concrete operation: send an HTTP HEAD request to a public URL and return only the status. This is specific and not a tautology, so an agent can select it for a status-only URL check. However, it does not acknowledge the nine optional schema parameters and does not differentiate from sibling tools, so it is not fully representative.

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?

Use is implied by the operation: when a HEAD status for a public URL is needed. There is no explicit guidance about when not to use it or which sibling tool to prefer, and no mention of how to choose among the nine optional parameters.

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

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

With no annotations, the description carries the full behavioral burden. It discloses one behavior ('Path discarded') but does not state whether the operation is read-only, what return value is produced, or how failures are handled.

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. The second sentence 'Path discarded.' is a bit fragmentary but still economical.

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 parameters, and no output schema, so an agent needs more context about expected inputs and return values. The description only identifies the general input kind and one discarded component, leaving the invocation largely underspecified.

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 mostly carries parameter meaning. The description adds the 'Figma' qualifier and the path-discarding behavior, but it does not clarify which of the nine optional parameters are relevant or should be supplied.

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

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

The description states a clear verb and resource ('Parse a Figma file URL'), which identifies what the tool operates on. It is distinguishable from sibling shape tools like github-repo-shape and jira-key-shape, though it does not explicitly name an alternative.

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

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

The description implies the tool should be used when a Figma file URL needs parsing, but it gives no explicit when-to-use guidance, prerequisites, or exclusions. It does not mention how this relates to sibling tools like normalize-url or browser-url-ok.

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

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

With no annotations, the description carries the behavioral burden, and it does disclose one important trait: no disk access, which prevents the assumption that this checks file existence or permissions. However, it doesn't specify the return contract (e.g., boolean/error) or whether other accepted fields are similarly shape-checked, leaving room for misinterpretation.

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 core purpose and no filler. The 'No disk access' qualifier is the only extra sentence and earns its place.

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

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

Although the schema describes each parameter, the tool accepts nine optional parameters and has no output schema, so the agent is left guessing which parameters to pass and what the result looks like. The description doesn't explain what makes a path safe, what happens with no arguments, or how the unrelated parameters relate to this tool.

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

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

Schema description coverage is 100%, so each parameter is already documented and the baseline is 3. The description adds only the 'safe' notion to the path field and provides no additional meaning for the other eight parameters.

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

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

The description states a concrete action ('Check whether a path looks safe') and a clear resource, and the title plus 'path' property narrow it to file paths rather than URLs. It is not explicit about what 'safe' means, and the 9-parameter schema suggests a broader shape-checking behavior the description doesn't acknowledge.

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 and no sibling tools are mentioned. The only usable hint is 'No disk access,' which implies a purely syntactic check but doesn't tell the agent when to choose this over URL/domain validators or how to treat the unrelated accepted parameters.

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

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

With no annotations, the description must carry behavioral disclosure, but it only reveals the use of Open-Meteo and the high-level result. It does not mention response format, network/failure behavior, rate limits, or that most schema fields appear to be ignored 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 a short, front-loaded phrase with no filler. It is concise, though it is a noun phrase rather than a complete imperative sentence.

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

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

Given a complex 9-parameter schema, no annotations, and no output schema, the description is too thin to support reliable invocation. It should identify `city` as the input, clarify that other fields are irrelevant, and describe the returned coordinate format.

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 describes all 9 parameters (100% coverage), so the baseline is 3. The description adds no mapping between 'a place' and the relevant parameter, but since the schema bears the documentation burden, there is no penalty below 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 the deliverable (latitude and longitude) for a place, and names the underlying service (Open-Meteo), which helps distinguish it from siblings such as weather-hint. It lacks a verb and does not identify the `city` parameter as the location input, so it is clear but not maximally 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?

There is no guidance on when to use geo-hint versus weather-hint or any other sibling. The description also does not indicate which of the nine schema parameters should be supplied, and all parameters are optional.

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

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

With no annotations, the description carries the full burden, but it only says 'Parse' and does not disclose whether the tool validates URL shape, returns an error for non-GitHub URLs, or what the parsed output looks like. The schema's many 'discarded' parameter descriptions hint at shape-check behavior that the description never explains.

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 is appropriately concise for a simple parse operation, though it could have spent one more clause on output or required input without hurting 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?

The tool has nine optional parameters, no output schema, and no annotations, yet the description only covers the basic purpose. It does not state which parameter to pass, what is returned, or how invalid/non-GitHub URLs are handled, making it insufficient 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, and the description does not add param-level meaning. It ties the operation to a GitHub URL but never identifies `url` as the key parameter (whose schema description is the generic 'HTTPS URL to normalize or cite'), leaving agents to infer the mapping among nine optional parameters.

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

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

The description uses a specific verb ('Parse') and resource ('owner and repo from a GitHub URL'), making the core function clear and differentiating it from sibling shape tools aimed at Figma, Jira, or domains. It does not explicitly mention the validation/shape-check behavior implied by the tool name, so it falls short of a 5.

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

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

The usage is implied: call this when you need owner/repo from a GitHub URL. However, there is no explicit when-to-use or when-not-to-use guidance, no mention of alternatives, and no statement about prerequisites like requiring a valid GitHub URL.

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

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

No annotations are provided, so the description carries the full burden for behavioral disclosure. It reveals that the tool counts stories and discards titles, but it does not disclose whether a network request is made, whether all inputs are ignored, what failure modes exist, or what the count response actually looks like.

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 efficient: two short sentences with no filler. 'Titles discarded' is a meaningful behavioral qualifier that earns its place, and the core purpose 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 no output schema, no annotations, and nine optional parameters, this description is too thin. It does not state whether the tool can be called with zero arguments, whether parameters like 'feed' or 'url' alter the result, or what the return value format is. An agent would likely have to guess before invoking 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 tool description adds no parameter-level meaning and does not clarify which, if any, of the nine parameters are relevant to counting Hacker News front-page stories. It neither helps nor hurts beyond the schema's own fields.

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

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

The description clearly states a specific verb and resource: 'Count current Hacker News front-page stories.' The added phrase 'Titles discarded' also tells the agent what the tool will not return. It does not explicitly contrast with sibling tools, so it misses the top bar for 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?

There is no guidance on when to use this tool versus sibling tools like web-fetch, browser-url-ok, or fetch-status. It also does not explain whether any of the nine optional parameters are needed or should be omitted, leaving the invocation conditions ambiguous.

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

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

No annotations are provided, so the description carries full responsibility for disclosing behavior. It only says the tool concerns 'common IANA timezone names' and gives no information about output format, side effects, whether input is required, or whether the seven schema parameters are ignored or meaningful. This falls well short of transparent behavioral disclosure.

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 closer to a phrase than a complete specification. It earns its place, yet it is under-specified rather than appropriately concise: a bit more structure, such as a verb and output description, would not be wasted.

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 schema containing seven optional parameters that do not obviously relate to the tool's stated purpose, the description is not complete enough for an agent to confidently select and invoke the tool. There is no explanation of return values, required inputs, or behavior.

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

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

Schema coverage is 100%, with each parameter individually described, so the baseline is 3. However, the description adds no parameter-level meaning and the parameters themselves (url, city, json, path, etc.) seem unrelated to IANA timezone names, which may confuse an agent about which parameter to supply.

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

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

The description identifies the domain (IANA timezone names) and use case (clock calls), but it lacks a verb: it does not say whether the tool returns a list, validates a zone name, or checks availability. It is slightly more informative than a tautology because it adds 'Common' and 'for clock calls,' but it does not clearly distinguish from sibling tools 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?

There is no guidance on when to use this tool versus alternatives such as timezone, utc-time, or validate-json. 'For clock calls' implies a context but does not explain when not to use it or what to use instead when needing conversion, validation, or other time operations.

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. It discloses one behavioral trait — output is reduced to group counts rather than full content — but says nothing about 404 handling, redirect behavior, auth expectations for 'public' access, or the unusual fact that most parameters are 'discarded' as the schema 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 single sentence is brief and front-loaded with the core action, but it is terse to the point of under-specification for a tool with nine parameters. The missing parameter mapping and behavioral details mean the sentence does not fully earn 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?

With 9 optional parameters, no output schema, and no annotations, an agent cannot determine which parameter selects the robots.txt source, what the response shape is, or how failures are reported. The description is seriously incomplete for a tool with this much surface area.

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

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

Schema coverage is 100%, but the parameter descriptions are borrowed from unrelated domains (city weather hint, feed, JSON validation, git ref) and no parameter is described as the robots.txt input. Only url or host plausibly apply, so an agent cannot determine which parameter specifies the target. The description fails to bridge the tool's purpose to its parameters.

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

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

The description states a clear verb+resource: fetch a public robots.txt, and adds a scope constraint ('return group counts only') that distinguishes it from a full-content fetch like web-fetch. It does not name sibling alternatives, but the core action and output restriction are unambiguous.

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

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

There is no guidance on when to use inspect-robots instead of siblings such as web-fetch, fetch-status, browser-url-ok, or playwright-url-ok, all of which can fetch a URL. No when/when-not conditions, prerequisites, or alternative routing 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?

No annotations are provided, so the description must carry the behavioral disclosure burden. 'Key discarded' indicates the input is not retained, which is useful, but the description omits whether the tool is read-only, what it returns, how validity is signaled, and any error behavior. This is minimal disclosure for a check-like 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 very short: two sentences. It front-loads the core purpose and adds a minor behavioral note. It is arguably under-specified, but there is no wasted wording.

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 optional parameters, no annotations, no output schema, and a description that does not align with the schema, the tool is effectively unusable from the documentation. The description does not explain what 'shape' means, what a valid response looks like, which parameter to use, or how this relates to the listed inputs.

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, but the description introduces a 'key' concept that has no corresponding parameter in the schema. The listed parameters (url, path, zone, query, etc.) are unrelated to a Jira issue key, and the description does not map its primary concept to any schema field. This mismatch prevents an agent from knowing what to pass.

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

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

The description states a specific verb and resource: 'Check a Jira issue key shape.' This distinguishes it from sibling shape-checking tools like github-repo-shape or domain-shape. However, the phrase 'Key discarded' is terse and the named resource is not reflected in any schema parameter, which slightly weakens 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 description gives no guidance on when to use this tool versus alternatives such as github-repo-shape or validate-json. It does not mention any conditions, exclusions, or alternatives. An agent must infer usage entirely from the name and schema.

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 does disclose a meaningful non-obvious behavior: the body is discarded, so only the HTTP status matters. However, it does not mention redirect handling, HTTP method, error behavior, or whether the check is read-only beyond the implied fetch.

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 concise: two short sentences with no filler. 'Body discarded' is a useful, distinct behavioral detail that earns its place. It could be slightly more informative, but the brevity is not itself a flaw.

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 9 optional parameters, no output schema, no annotations, and many sibling tools with overlapping functionality, the description is far too sparse. It does not specify which parameter carries the URL, what the response format is, when to choose this tool over fetch-status, or what types of status results are returned. An agent would likely need to experiment or inspect other tools to use this 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%, which normally sets a baseline of 3, but the description fails to bridge the gap between its stated purpose and the 9 optional parameters. The `url` parameter is described as 'HTTPS URL to normalize or cite', not as the library docs URL to check, and the description does not explain how the other parameters like `ref`, `city`, `feed`, `json`, `path`, `timezone`, or `query` relate to the tool. An agent cannot confidently know which parameter, if any, is needed to invoke this tool correctly.

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

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

The description states a specific operation—returning the HTTP status of a public library docs URL and discarding the body—so it is not a tautology. However, 'public library docs URL' is ambiguous, and the description does not distinguish this tool from siblings such as fetch-status or browser-url-ok. The heterogeneous 9-parameter schema also muddies what the tool actually accepts.

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 like fetch-status, normalize-url, or web-fetch. It does not state prerequisites, exclusions, or which sibling should be preferred in other cases. An agent is left to infer usage solely from the name and 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?

'Values discarded' is a meaningful behavioral disclosure beyond the schema, and there are no annotations to contradict. However, with zero annotations, the description still does not state read-only status, behavior on invalid JSON, or whether the count is top-level or recursive.

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 core purpose and a concise behavioral note. No filler or repetition.

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 short description, the tool has nine parameters, no output schema, and a long sibling list. The description does not say which parameter holds the JSON, what the return value looks like, or whether nested keys are counted, leaving too much to inference.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds no parameter-level value: it does not identify which input contains the JSON or how the many unrelated parameters are 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 clearly names the operation ('Count keys') and the resource ('a JSON object'), and 'Values discarded' sharpens the scope. It is distinguishable from siblings like validate-json, though it does not explicitly name the 'json' parameter or clarify whether nested keys count.

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

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

There is no guidance on when to use this tool versus alternatives such as validate-json or hn-front-count. No when-to-use, exclusion, or sibling-selection guidance is provided.

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

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

With no annotations supplied, the description carries the behavioral disclosure burden. It does add a useful behavioral trait ('Query and fragment are dropped') beyond the name, but it does not disclose output format, error behavior for invalid URLs, whether the URL is actually fetched, or what happens with non-URL inputs.

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 action first and the filtering behavior second. Every word earns its place and no irrelevant detail is included.

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 high schema coverage, the definition is incomplete for a tool with nine optional parameters and no output schema. The agent is not told that `url` is the effective input, whether other parameters are ignored, or what the returned origin/host/path value looks like, making correct invocation uncertain.

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 descriptions cover 100% of the nine parameters, so the baseline is 3. The tool description adds only marginal meaning by clarifying that `url` produces origin/host/path with query and fragment removed; it does not clarify the confusing role of the eight auxiliary 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 names a concrete operation ('Return origin, host, and path for a URL') and specifies what is excluded ('Query and fragment are dropped'), which is enough to identify the tool's purpose. It does not explicitly compare against sibling URL tools such as browser-url-ok or fetch-status, and the phrase 'origin, host' is slightly redundant, so it stops short of a perfect 5.

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

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

There is no statement about when to use this tool versus alternatives, nor any warning about when not to use it. The schema has nine optional parameters, but the description never points to `url` as the relevant input or tells the agent that the other fields are validation-only or ignored.

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

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

No annotations exist, so the description carries the burden of disclosing side effects, return values, and operational behavior. It adds only 'No browser is launched,' which is one useful behavioral fact, but it never states whether a network request is made, what a successful check returns, or how errors are reported.

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 core action is front-loaded and the second sentence adds distinct value by warning that no browser is launched. Every sentence earns its place.

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

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

With nine optional parameters, no output schema, and no annotations, the description is too thin to define a complete call contract. It doesn't specify what 'ok' means, what to pass, what response to expect, or when to pick this over related tools. It is not entirely missing, but it is clearly under-specified.

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

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

Schema description coverage is 100%, so the baseline is 3. The description doesn't explain how to choose among the nine optional parameters or identify which one is the primary subject, but the schema already documents each field; the description simply adds no extra parameter-level guidance.

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 says 'Check whether a URL can be opened,' which is a concrete verb and resource, and 'No browser is launched' gives a useful qualification. It doesn't define exactly what 'can be opened' means (HTTP 200, reachability, string shape) and doesn't name sibling tools, so it falls short of a 5.

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

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

There is no statement about when to prefer this tool over siblings like browser-url-ok, fetch-status, or normalize-url. 'No browser is launched' implies a lightweight context but does not establish a routing rule or exclusion, so an agent must infer the right choice from 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 behavioral burden. It does disclose that the query is discarded, implying no persistence or side effects, and the schema descriptions reinforce that other inputs are discarded as well. It does not disclose the output shape, error behavior, or whether any network activity occurs, 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 sentences with the core purpose front-loaded and a behavioral note following. There is no filler, and every sentence contributes useful information.

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

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

The description is too sparse for a tool with nine optional parameters, no annotations, and no output schema. It does not say which parameter actually matters (beyond inference from the name), what the count result looks like, or why the other eight parameters are present.

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

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

Schema description coverage is 100%, so the baseline is 3. The description identifies the query text as the thing to measure, and the schema already labels the query parameter and its discard behavior, so the tool description adds little semantic value beyond the structured 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 uses a specific verb ("Count") and resource ("characters in a search query"), so an agent can tell this is a length-checking utility rather than a search or fetch tool. However, it does not explicitly differentiate among the many sibling count/check tools or state what the 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 choose search-query-len over siblings such as validate-json, normalize-url, or memory-key-count. The description gives no context, prerequisites, or exclusions, leaving the selection decision entirely to the agent's inference from the name.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only says 'short catalog,' revealing nothing about side effects, network access, return values, or failure modes. The schema hints that some inputs are discarded, but the description itself is silent.

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 the brevity is under-specification rather than effective conciseness. A single vague clause does not earn its place as an operational tool definition.

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

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

With seven heterogeneous parameters, no annotations, and no output schema, one short clause is wholly insufficient. An agent cannot infer what inputs are meaningful, what the catalog returns, or what constitutes a successful invocation. The definition is incomplete for even a basic 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?

The schema provides descriptive text for all seven parameters, so schema coverage is high and the baseline is 3. The description adds no parameter-level meaning and does not explain how the listed fields relate to HTTP status codes, but it does not actively misstate the parameters.

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

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

The description is essentially a noun phrase that restates the tool name: a 'catalog' of 'status codes'. It gives no verb or action, so an agent cannot tell whether the tool lists, looks up, validates, or generates HTTP status codes. It also does not distinguish itself from sibling tools like 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 provided about when to use this tool versus alternatives. There are no conditions, exclusions, or mentions of sibling tools. An agent has no basis for deciding whether status-catalog 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It does disclose one key trait: 'Prompt discarded' tells the agent the input prompt will not influence the result. However, it does not address the seven schema parameters or whether they are ignored or used, which is a meaningful transparency 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 extremely compact—two short sentences—with the primary purpose stated first and the behavioral qualifier second. Every word contributes: the first sentence gives the action and resource, the second states a necessary constraint. This is well-structured for an agent scanning tool definitions.

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 clean purpose statement, the tool exposes seven optional parameters with no explanation of their relationship to the returned template. An agent cannot tell whether passing url, json, or city changes the template or is pointless, and no output schema is given. The missing 'all inputs are ignored' disclosure is material for a tool with this many parameters.

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

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

The description itself says nothing about parameters. Since the input schema already provides descriptions for all seven properties, the baseline is 3, and the description neither adds nor weakens parameter semantics. The 'Prompt discarded' sentence does not clarify how the parameters relate to the tool's 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 names a specific verb and resource: 'Return a three-step thinking template.' This clearly distinguishes it from the sibling utilities such as validate-json, web-fetch, and others. The second sentence adds the clarifying constraint that the prompt does not shape the output.

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 function statement implies when to call it, namely when a three-step thinking template is needed. However, it does not explicitly say when not to use it or how it compares to sibling tools. Usage guidance is only implicit, with no exclusions or alternatives 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?

No annotations are present, so the description carries the full behavioral burden. It only states the output concept and says nothing about side effects, discarded inputs, required arguments, or output format. The schema's 'discarded' notes do not count because they are structured data, not description content.

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, making it easy to parse. However, its brevity comes at the cost of omitting essential invocation details, so it is not optimally complete.

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 nine parameters, a seven-word description is severely under-specified. An agent cannot determine which parameter holds the timezone, what the response looks like, or whether the call has side effects, making reliable invocation unlikely.

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

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

Although schema coverage is 100%, the description's only parameter-level contribution, 'IANA timezone', does not map to any visible schema property such as ref, url, city, feed, host, json, or path. This creates confusion about which input actually carries the timezone, rather than adding useful meaning.

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

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

The description clearly identifies the tool's purpose: returning the current time for a named IANA timezone. It is concise and not a tautology, but it does not differentiate from sibling tools like utc-time or iana-zones, and the visible schema does not show a timezone parameter.

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

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

The description provides no when-to-use guidance and no mention of alternatives. The phrase 'named IANA timezone' only weakly implies a use case; it does not explain when to prefer this tool over utc-time or iana-zones.

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 behavioral burden, but it only states what the tool returns. It does not mention that the listed parameters appear to be discarded or ignored, nor does it specify the timestamp format or confirm that no external access occurs.

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

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

The description is very short, but this is under-specification rather than effective conciseness. It omits the return format, parameter behavior, and any relationship to the unusual input schema.

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

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

For a tool with seven seemingly unrelated parameters, no annotations, and no output schema, the four-word description is grossly insufficient. An agent cannot tell whether the parameters matter, what the exact return value is, or why the schema includes these properties.

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 descriptions for all seven properties, so schema coverage is high and the baseline is 3. However, the descriptions are mostly unrelated to a UTC timestamp tool and mainly say values are 'discarded', which does not genuinely help an agent understand whether any parameter is needed.

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

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

The phrase 'Current UTC timestamp' conveys that the tool returns the current UTC time, but it is a noun phrase without an explicit verb and gives no hint about the odd set of input properties. It also does not distinguish itself from sibling tools like timezone or iana-zones.

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

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

No guidance is provided about when to use this tool instead of related siblings, such as timezone or iana-zones. An agent is left to infer the intended use case from 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?

No annotations are provided, so the description bears full responsibility. It usefully discloses that the body is discarded, establishing a non-persistence side effect. Yet it does not disclose what the tool returns on valid or invalid JSON, nor does it reconcile the many unrelated schema properties with the stated JSON-only purpose.

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 redundant wording. The core purpose is front-loaded, and every word contributes to the definition. It is a model of concise, scannable tool documentation.

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?

Overall, the definition is minimally viable but leaves open several questions: which parameter represents the body, what happens when the JSON is invalid, and why the schema includes many unrelated parameters. With no output schema, the return value is also unspecified, so an agent may need to infer behavior from the tool's name 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?

The input schema provides detailed descriptions for every parameter, including a clear one for 'json' ('JSON text to validate; discarded after the check'). The description itself does not explicitly map the term 'body' to the 'json' parameter, but the schema already conveys enough meaning for an agent to infer the correct parameter.

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

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

The description states a specific action ('Check') and target ('whether a body is valid JSON'), clearly indicating the tool validates JSON syntax. It is distinguishable from sibling shape-checkers by its focus on JSON, though it does not explicitly name an alternative or contrast with them.

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

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

The intended usage is implied: use this when you need to determine if a body is valid JSON. However, there is no explicit guidance about when not to use it, what alternatives exist, or any prerequisites or context that would route an agent to this tool rather than a different one.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It mentions the Open-Meteo backend and current temperature, but does not explain that most input schema fields are discarded, what happens for unknown cities, whether authentication is needed, or what the response format looks like.

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 efficiently communicates the tool's purpose and data source without redundant phrasing.

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?

Even though the purpose is simple, the tool has 9 parameters, no output schema, and no annotations. A one-sentence description does not adequately clarify which parameter to supply, how results are returned, or how to handle failures, leaving important context 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?

Schema description coverage is 100%, so the baseline is 3. The description only highlights 'city', while the schema already documents each parameter and notes that most are discarded. The description adds little meaning beyond what the schema provides.

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

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

The description clearly states the tool's core function: returning the current temperature for a city using Open-Meteo. It is distinct enough from siblings like geo-hint, though it lacks an explicit imperative verb and does not directly contrast itself with related tools.

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

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

There is no guidance about when to use this tool versus geo-hint, lib-docs-hint, or other siblings. The word 'city' implies a weather use case, but no conditions, exclusions, or alternative tool references are provided.

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

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

With no annotations, the description carries the behavioral disclosure burden. It does communicate a key behavioral trait: the body is discarded, preventing misuse for content retrieval. However, it omits other relevant behaviors such as redirect handling, timeout behavior, error responses, or whether any parameters beyond 'url' actually affect the request.

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

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

The description is a single efficient sentence with no filler. It front-loads the main output and immediately states the important limitation that the body is discarded.

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

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

The tool has nine optional parameters, no output schema, and many closely related siblings, yet the description provides no return format details, no parameter selection context, and no guidance for choosing among the many URL-related tools. The description is too sparse to fully support correct invocation in this 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 each of the nine parameters is documented in the schema. The description adds no parameter-level meaning, but the baseline of 3 applies because the schema already carries the semantic load.

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 HTTP status and content type for a public URL and discards the body, so the core purpose is understandable. However, it does not distinguish web-fetch from close siblings like fetch-status or browser-url-ok, and the schema exposes many non-URL parameters that the description does not explain.

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

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

There is no guidance about when to use this tool versus siblings such as fetch-status, normalize-url, or browser-url-ok. The description gives no exclusions, prerequisites, or alternative recommendations, leaving the agent to guess based on tool names alone.

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

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

The phrase 'Title discarded after the call' discloses a useful behavioral trait: the title is not retained. With no annotations present, this is the only behavioral disclosure; it does not clarify whether the tool makes a live network request, returns a boolean, or handles missing pages/errors.

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

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

The description is only two sentences, front-loads the core purpose first, and contains no filler. The brevity is effective, though it comes at the cost of missing input/output mapping and invocation details.

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

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

With no annotations, no output schema, and an eight-parameter input schema, the description is far too thin. It never identifies which parameter carries the Wikipedia title, what the result looks like, or how errors are surfaced, so an agent cannot reliably call 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?

Although the schema has per-parameter descriptions, the tool description introduces a 'title' concept that appears in no schema property, so an agent cannot bind the required input. It adds no clarifying meaning for the eight listed parameters, many of which look like decoys for unrelated tools.

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 whether a Wikipedia title exists.' This clearly separates it from sibling tools like file-path-ok or normalize-url. However, the schema contains no `title` parameter, so the purpose is clear conceptually but not operationally linked to the inputs.

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

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

The description implies the tool is for Wikipedia title existence checks, but it provides no explicit when-to-use or when-not-to-use guidance. It also names no alternatives or sibling tools, leaving the agent to infer suitability from the title and purpose alone.

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