ISO country ME

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

With no annotations, the description carries the disclosure burden. It does disclose 'Task text discarded' and enumerates the returned artifacts, which is useful. However, it does not explain side effects, network/cost implications of 'remote MCP hops,' or what happens when parameters are provided beyond the schema-level 'discarded after shape check' notes.

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 every sentence earns its place: one sentence for purpose, one for return content, one for the critical discard behavior. It is front-loaded and free of 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 a concise description and fully described parameters, the tool has 9 optional params, no output schema, and no annotations. The description does not explain which parameters to pass, whether any are needed, or how the returned CLI setup/how-it-works content relates to the input. This leaves 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 is 3. The main description adds no parameter-level meaning beyond the schema, but that is acceptable because each of the 9 parameters already has a clear description in the input schema. The description's 'Task text discarded' is a general behavioral remark, not a parameter clarification.

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 resource ('Monid') and an action ('Find'), and lists concrete return contents (CLI setup, how-it-works, skill file, remote MCP hops). It is distinguishable from the sibling tools, which are mostly URL/format/time/weather utilities, though the phrase 'public pay-per-call tool gateway' is somewhat jargon-heavy.

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

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

The description gives no explicit guidance on when to use this tool vs. the many siblings, no alternatives, and no exclusions. The only implicit signal is that this tool relates to Monid, leaving an agent to guess whether it should be selected for gateway-setup questions or something else.

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 does reveal that no browser is launched, which is useful, but it does not state what the check actually performs, what response or result the caller receives, or that most of the nine schema parameters are unrelated and discarded. Schema field descriptions hint at discarding, but the tool description itself omits this important 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 two short sentences and front-loads the core action first. It contains no filler, and the second sentence adds a valuable non-goal that helps define scope.

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

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

With nine optional parameters, no annotations, and no output schema, the description is far too sparse. It omits the expected return value, network or timeout behavior, which parameter is practically required, and how this tool relates to the large sibling list. An agent would not have enough information to invoke it confidently.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds no parameter-specific meaning, though it helps map the `url` property to the openability check. However, the schema's own description of `url` ('HTTPS URL to normalize or cite') slightly conflicts with the tool's stated purpose, and the description never clarifies that the eight non-URL parameters are irrelevant to this check.

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

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

The description states a clear verb and resource: checking whether a URL can be opened. The additional clause 'No browser is launched' helps distinguish it from browser-based sibling tools like playwright-url-ok. However, it does not explicitly name alternatives or clarify whether 'opened' means an HTTP fetch, DNS resolution, or some other check.

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

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

There is no explicit when-to-use or when-not-to-use guidance and no alternative tools are named. The 'No browser is launched' clause provides only an implicit reason to prefer this over browser-launching tools, but it does not say when to use playwright-url-ok, normalize-url, fetch-status, or other URL-related 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 behavioral note ('Expression discarded'), but it omits side effects, output behavior, error handling, or any indication of what happens on invalid input. The disclosure is too thin to be genuinely transparent.

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

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

The description is short and front-loaded, with no filler words. Both sentences carry intended content, though the overall definition is under-specified 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?

Given no annotations, no output schema, nine parameters, and 27 sibling tools, this description is far from complete. It fails to specify how the expression is passed, what the tool returns, what inputs are valid, or how this tool relates to siblings. An agent cannot reliably select or invoke it correctly.

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

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

Although the schema has 100% parameter description coverage, the description does not connect 'a+b style arithmetic' to any actual parameter. None of the nine schema properties—ref, url, city, feed, host, json, path, query—accepts an arithmetic expression. The description actively misleads by referencing an input that the schema does not expose.

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 ('Evaluate a+b style arithmetic'), so it is not a tautology. However, it does not explain how the expression is supplied, and the input schema contains no parameter that plausibly holds an arithmetic expression. This makes the stated purpose hard to act 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 implies the tool is for arithmetic evaluation, but it gives no explicit guidance on when to use it instead of any of the many sibling tools, nor any exclusions or prerequisites. There is no context about preferred input forms or typical user intents.

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 'Page content is not stored' clause is a real behavioral disclosure beyond the schema, and the read-only-sounding operation is a useful signal. However, annotations are absent, so the description carries the full burden, and it does not address network side effects, authentication, or output behavior beyond naming the three returned 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?

Two sentences with the core operation front-loaded and a valuable privacy qualifier second. There is no filler, and every clause 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?

With no output schema, no annotations, and a large parameter surface, the description is too thin. It names three return values but not their structure or format, and it does not specify which inputs actually drive the URL-citation behavior versus the other discarded 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?

Schema description coverage is 100%, so the baseline is 3 even though the description adds no parameter-level detail. The description only implies the url parameter through 'for a URL' and does not clarify how the many non-URL optional parameters relate to the tool's main 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 clearly states a concrete action: return host, scheme, and HTTP status for a URL, and adds a meaningful distinction with 'Page content is not stored.' This is specific enough to separate it from siblings like web-fetch, which would return content, and fetch-status, which likely returns only 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?

There is no explicit when-to-use or when-not-to-use guidance, and no alternative tools are named. The privacy clause 'Page content is not stored' hints that this is not a content-fetching tool, but the agent is left to infer when to choose citation over the many URL-related 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 provided, the description carries the full disclosure burden. It contributes one genuine behavioral trait ('No identifiers are retained', a privacy/no-persistence guarantee), but it does not say whether the tool makes network calls, what the response looks like, whether it consumes a single parameter or inspects all of them, or how errors surface. The schema's repeated 'discarded after...' notes do some of this work, but the description itself is thin for an unannotated 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 the purpose first and the privacy guarantee second; there is no filler or redundancy. Every word earns its place. The brevity is partly a symptom of under-specification, but that is more appropriately penalized under contextual completeness and behavioral transparency.

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?

A 9-parameter classifier with 28 siblings, no output schema, and no annotations needs far more context than this. The agent cannot predict the response format, the classification taxonomy, whether parameters are mutually exclusive alternatives, or what a 'compatible' result means. The per-parameter 'discarded' notes in the schema partially compensate, which keeps this from being a 1.

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 of 3 applies. Every parameter is already documented in the schema (e.g., 'Git ref name; discarded after the shape check', 'Search text; discarded after the length check'). The tool description adds nothing about parameters, so no credit beyond the schema is warranted.

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

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

The description names a verb and resource ('Show how this request is classified'), but 'classified' is left undefined - the agent is never told what categories, tool mappings, or outcomes the classification produces. The heterogeneous parameter list (git refs, URLs, cities, RSS feeds, JSON, paths, timezones, queries) hints at a routing tool that maps a request to one of the 28 sibling domains, but the description never states this, leaving the purpose genuinely vague rather than tautological.

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 zero guidance on when to use this tool versus any of the 28 siblings such as validate-json, normalize-url, weather-hint, or iana-zones. The obvious intended use - call this when unsure which domain-specific tool applies - is never stated, and no alternatives, exclusions, or prerequisites 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 carries the full behavioral burden. It only discloses the lack of WHOIS/ownership data; it does not state output format, validation rules, side effects, or what happens with the many other accepted parameters. The schema notes that several fields are 'discarded,' but the description itself provides almost no behavioral context.

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

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

The description is a single efficient sentence with the core action front-loaded and no filler. It is concise, though arguably too terse given the mismatch between the narrow description and the broad 9-parameter 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 9 optional parameters, no annotations, no output schema, and a description that only mentions hostnames, this is severely incomplete. An agent cannot determine which parameters are relevant, what the return value looks like, or how to invoke the tool correctly for the other schema fields.

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 description. The description adds no meaning beyond the word 'hostname' and does not clarify how 'host' relates to the split or why url, city, feed, json, path, zone, and query are accepted.

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 ('Split'), a resource ('hostname'), and an outcome ('into labels'), and explicitly excludes WHOIS/ownership data, which helps distinguish it from ownership-related or other shape tools. However, the input schema lists eight other unrelated parameters with no explanation of their role, creating ambiguity about the tool's actual scope.

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

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

The phrase 'without WHOIS or ownership data' implies this tool is for pure hostname lexical shape checks, not ownership lookups. But there is no explicit when-to-use/when-not-to-use guidance and no pointer to sibling tools such as github-repo-shape or file-path-ok, leaving the routing decision mostly 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?

The phrase 'HEAD' and 'status only' usefully signals a read-only operation that does not retrieve content, which matters because no annotations are provided. However, it does not disclose redirect handling, error behavior, timeout behavior, or the fact that the many non-URL parameters appear to be discarded or ignored. The safety profile is only partially transparent.

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

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

The description is a single sentence with no filler, and the core constraint 'status only' is stated directly and front-loaded. It is appropriately concise for what it attempts to express.

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 should clarify what 'status' means and how the nine optional parameters relate to the operation; it does neither. The URL-only phrasing leaves the purpose of ref, city, feed, json, zone, and query unexplained, making the definition insufficient for reliable 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 input schema already documents each of the nine parameters individually; the description adds no parameter-level meaning. The mismatch between the URL-centric description and the heterogeneous schema is not addressed, but the baseline holds because the schema itself is complete.

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

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

The description names a specific HTTP verb (HEAD), a resource class ('public URL'), and an output scope ('status only'), so the core action is clear. However, the input schema contains nine heterogeneous optional parameters such as ref, city, feed, json, and zone, which the description never acknowledges. This makes the tool's full purpose ambiguous despite the clear URL-focused phrasing.

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 about when to choose fetch-status over sibling tools like web-fetch, browser-url-ok, playwright-url-ok, or normalize-url. It implies a public URL HEAD check but provides no exclusions, prerequisites, or alternative-selection conditions.

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

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

With no annotations, the description carries the full behavioral burden, but it only discloses 'Path discarded.' It does not state whether parsing is read-only, what happens with invalid Figma URLs, what fields are returned, or whether network access occurs. This is under-disclosed for a tool that needs to be invoked without additional context.

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

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

Two short sentences with no filler, and the main action is front-loaded. It is appropriately concise but slightly cryptic: 'Path discarded' is a fragment that could be clearer.

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 output schema and no annotations, yet the description does not define what a successful parse returns, what constitutes a valid Figma file URL, or how errors are reported. For a tool with a 9-parameter generic schema, this is under-specified, though the basic input domain is clear.

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; individual parameter descriptions already explain that ref, city, feed, json, zone, and query are discarded. However, the tool description adds only 'Path discarded' and does not explicitly say which of the nine optional parameters is the relevant input, leaving the url parameter to be inferred from the tool name.

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

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

The description names a specific verb and resource: 'Parse a Figma file URL.' This distinguishes the tool from generic URL siblings like normalize-url and from other shape checkers such as domain-shape or jira-key-shape. The note 'Path discarded' adds a scoping detail, though it is ambiguous about whether it refers to the URL path or the path input 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 phrase 'Parse a Figma file URL' implies the tool is for Figma URL inputs, but the description gives no explicit when-to-use guidance, no exclusions, and no comparison to sibling tools such as normalize-url or browser-url-ok. It is enough to infer context but not enough to choose confidently among URL-related 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. It does disclose one important behavior: 'No disk access,' which signals a side-effect-free, non-filesystem-touching check. However, it does not mention return values, failure behavior, or whether any network/other side effects are possible.

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 has no filler. The key safety guarantee ('No disk access') is front-loaded. It could be considered too terse, but as far as conciseness, every word earns its place.

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

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

For a tool with 9 parameters, no output schema, and no annotations, this is under-specified. It does not explain what 'looks safe' means, what the tool returns, how to choose the correct parameter, or how it relates to sibling validators. This is insufficient for an agent to confidently invoke it.

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

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

Schema coverage is 100%, so the schema already documents all parameters. The description adds no parameter-level meaning beyond the schema, and given the schema contains many unrelated-looking fields, it does not help the agent decide which parameter matters. Baseline 3 applies because the schema covers the details.

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 verb ('check') and resource ('a path'), and the phrase 'looks safe' suggests a validation or shape-check operation. However, it does not define what 'safe' means or distinguish itself from sibling validators like wiki-title-ok 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?

There is no guidance about when to use this tool versus alternatives. 'No disk access' hints at a non-invasive check, but the description does not state conditions, exclusions, or preferred use cases compared to the many sibling 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, the description must carry the behavioral burden. It only reveals an external dependency on Open-Meteo; it does not disclose that most inputs are discarded, which input triggers the lookup, whether a network call is made, or what the response contains.

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

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

The one-sentence description is front-loaded and free of fluff, but it is severely under-specified for a tool with nine optional parameters and no output schema. Conciseness here comes at the cost of necessary 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?

An agent cannot reliably invoke this tool correctly: it does not know which parameter to populate, what the return value looks like, or what happens when multiple unrelated parameters are supplied. With no output schema and no annotations, almost all invocation context is 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 descriptions cover 100% of the parameters, so the baseline is 3 and the top-level description is not obligated to repeat them. Still, the description adds no clarity about which parameter represents the place, and the schema note that city is 'discarded after the call' conflicts with the apparent geocoding purpose.

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

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

The description states a recognizable operation—returning latitude and longitude for a place via Open-Meteo—so it is not a tautology. However, it never maps 'a place' to any of the nine schema parameters, and the unrelated parameter names make the intended target 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 about when to prefer geo-hint over sibling tools such as weather-hint, timezone, or normalize-url. No preconditions, exclusions, or alternative routing are mentioned, leaving the agent to infer usage from the tool 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 provided, the description carries the full behavioral burden, but it discloses nothing about side effects, read-only nature, what happens for non-GitHub URLs, or what the output looks like. The schema's repeated 'discarded after...' notes are not reflected in the description.

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

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

The description is a single, front-loaded sentence with no filler or repetition. Every word contributes to the stated purpose.

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

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

This is an extraction/parse tool with no output schema and no annotations, so the description should specify the primary input parameter, return shape, and failure behavior. The one-sentence description covers only high-level intent and is 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 coverage is 100%, so the schema already documents every parameter. The description adds GitHub-specific meaning to the generic 'HTTPS URL' parameter, but it never names `url` or explains why eight unrelated parameters exist, leaving the mapping between description and schema incomplete.

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 ('Parse') and resource ('owner and repo from a GitHub URL'), and the GitHub scope clearly differentiates it from sibling shape tools like figma-url-shape and jira-key-shape. The intended function is immediately understandable.

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

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

There is no when-to-use guidance, no mention of which sibling tools are alternatives, and no indication that `url` is the relevant input among the nine optional parameters. The description leaves usage 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 behavioral burden. It discloses the core behavior (counting, and not returning titles) and implies a read-only live operation, but it does not address output format, failure modes, or whether the optional input parameters are ignored.

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

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

Two terse, front-loaded sentences with no wasted words. The core operation comes first, and the exclusion is separated for emphasis.

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 and no output schema, yet the description does not specify that no arguments are needed or what exact return shape to expect. The cryptic 'Titles discarded' does not resolve what titles are being referenced, leaving an agent with meaningful uncertainty when 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?

Schema coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning, and it does not clarify whether any of the 9 optional parameters influence the count. Still, the schema itself provides descriptive explanations for each parameter.

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

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

The description states a specific verb ('Count'), a precise resource ('current Hacker News front-page stories'), and an explicit exclusion ('Titles discarded'). This unambiguously tells an agent what the tool does and distinguishes it from generic fetch or 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 specialized purpose directly implies when to use this tool: when a count of current HN front-page stories is needed. However, it does not name alternatives, state when not to use it, or acknowledge the many sibling tools with overlapping generic capabilities.

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 does not state whether the tool returns a list, accepts arguments, has side effects, or how the many input fields are relevant; 'Common IANA timezone names' is a content label rather than a description of 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 text is brief and free of wordiness. However, it is a noun phrase rather than a structured tool description, and its brevity results in under-specification rather than efficient completeness.

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

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

For a 9-parameter tool with no output schema and no annotations, this description is far too incomplete. It does not explain what the tool returns, why the unrelated parameters exist, or how an agent should invoke it successfully.

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 main description adds no parameter-level meaning. The schema documents each parameter (including that fields like 'ref' and 'json' are discarded), but the main description does not help reconcile those parameters with timezone names.

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

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

The description identifies the resource as common IANA timezone names and ties it to clock calls, so an agent can roughly guess the tool's subject. However, it lacks a verb and an explicit statement of what the tool does, and the input schema's parameters (url, path, json, host) are unrelated to timezone names, making the purpose genuinely 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 phrase 'for clock calls' hints at a use case, but there is no guidance about when to use this tool versus the sibling tools 'timezone' or 'utc-time'. With 26 sibling tools and no exclusions or alternatives mentioned, the description provides almost no routing help.

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 alone must disclose behavior. It communicates that only group counts are returned (a useful constraint) but omits any side effects, network/rate-limit implications, or how failures/timeouts are handled – minimal transparency for a fetching 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?

A single 10-word sentence with no redundant wording; the core action and output constraint are front-loaded. It is appropriately brief, even if it leaves behavioral details to 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?

The tool has 9 optional parameters and no output schema or annotations, yet the description only names the resource and result type. It never explains how to identify the target robots.txt, what 'group counts' means, or what the invocation shape looks like, leaving an agent under-informed.

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, but the description adds no parameter-level guidance and does not state which optional parameter (likely host) supplies the robots.txt location. The schema descriptions are individually complete, though several properties appear unrelated to robots inspection; the description fails to bridge them 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?

States a clear verb ('Fetch'), a specific resource ('public robots.txt'), and the exact output shape ('group counts only'). This distinguishes it from siblings like web-fetch (full content) and fetch-status (availability), so an agent can tell what it does.

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

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

The description implies the tool is for robots.txt analysis but never explicitly says when to choose it over web-fetch, fetch-status, or domain-shape. There is no when-not-to-use guidance or mention of alternatives, so the agent must infer the context from the name and resource type.

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. 'Key discarded' usefully indicates the input is not retained, but the description does not disclose whether the tool makes network calls, returns a boolean, throws on invalid keys, or has other side effects.

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

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

The description is short and front-loaded, with no filler. But it is under-specified for a tool with nine parameters and no output schema, leaving critical invocation details absent.

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

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

Given nine parameters, no annotations, and no output schema, the description is severely incomplete. It does not explain which parameter to pass, what 'shape' means, what the tool returns, or how errors are handled, making correct invocation impossible from the definition 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 schema exposes ref, url, city, feed, host, json, path, and query, but none of these parameters represents a Jira issue key. The description mentions 'Key' but never maps it to a schema property, so an agent cannot determine what input to provide. Schema descriptions exist, but they are for unrelated shape checks and do not compensate for the missing core 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 and resource: 'Check a Jira issue key shape.' This clearly distinguishes it from sibling shape-checking tools like github-repo-shape or domain-shape. However, it does not state what a valid shape is or what result is produced, so it is not fully specified.

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

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

There is no guidance on when to use this tool versus alternative shape-checking tools. The sibling tool names suggest related functionality, but the description does not mention any conditions, exclusions, or alternatives.

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

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

The description discloses a useful behavioral trait by stating that the body is discarded, and it implies a read-only network request. Since no annotations are provided, the description carries the burden, but it does not mention redirects, timeouts, or error behavior; still, this is acceptable for a simple status tool.

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

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

The description is two short sentences with no filler. It front-loads the core purpose and adds only one clarifying clause about the discarded body.

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

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

With no output schema, no annotations, and a nine-parameter schema that does not obviously align with the description, the tool is under-specified. The agent still lacks clear guidance about the return format and exactly which input to provide.

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

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

Despite 100% schema coverage, the schema's 'url' parameter is described as 'HTTPS URL to normalize or cite', which conflicts with the tool's stated status-check purpose, and eight unrelated optional parameters create ambiguity. The description does not specify which parameter should carry the docs URL, making invocation uncertain.

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 ('HTTP status') and a specific target ('public library docs URL'), and 'Body discarded' clarifies that it is not a content-fetching tool. It is reasonably clear, though it does not explicitly differentiate from siblings 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 use case is implied: use this when you need only the HTTP status of a library docs URL and not the body. However, it does not name alternatives or state when not to use this tool, so an agent must infer the boundary from 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?

Annotations are not provided, so the description must carry the behavioral burden. It does disclose that values are discarded, but it does not explain whether keys are counted at the top level or recursively, what happens with invalid JSON, or what return format is produced.

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 free of filler: the first sentence names the operation and the second adds the value-discarding behavior. It is well structured but too terse to compensate for the mismatched 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?

With multiple schema parameters, no required fields, no annotations, and no output schema, a two-sentence description that never identifies the JSON input or the result format is severely incomplete. An agent cannot confidently invoke this tool 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 mismatched with the tool: ref, url, city, feed, host, json, and path are each described as being checked or discarded, and none is identified as the JSON object whose keys are counted. The description adds no mapping between the JSON object and any parameter.

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

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

The description states a specific operation — count keys in a JSON object — and explicitly notes that values are discarded, which gives it a clear core purpose. However, it does not connect that operation to any of the listed parameters, so an agent cannot tell which input represents the JSON object.

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 its siblings. There is no mention of alternatives, exclusions, or context that would help an agent route to this tool rather than validate-json or domain-shape.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It does disclose that query and fragment are dropped, which is useful, but it omits the return format, normalization rules, and any side effects. The schema also reveals that many unrelated parameters are accepted and discarded, which the description does not clarify.

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. Every word contributes meaning, and the key behavioral caveat about query and fragment is included 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?

The tool has no output schema, so the description should explain return values clearly; it only names the components without specifying structure or format. More importantly, the input schema lists 9 optional parameters with no required fields and several that appear unrelated to URL normalization, leaving an agent unsure what to pass or what happens with the extra 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. The description adds a small amount of meaning by explaining that URL query and fragment are dropped, but it does not clarify which of the 9 optional parameters matter for this tool, especially given the many unrelated-looking fields in the schema.

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

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

The description names a specific operation and resource: 'Return origin, host, and path for a URL.' It also adds a meaningful scoping detail by stating that query and fragment are dropped. It does not explicitly distinguish itself from sibling URL-related tools, 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?

Usage is implied: an agent can infer this tool is for extracting origin, host, and path from a URL, and the note about dropping query/fragment hints at when it is not appropriate. However, it does not explicitly mention alternatives, prerequisites, or when-not-to-use conditions.

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

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

With no annotations, the description itself must carry behavioral disclosure, and it does disclose one meaningful trait: no browser is launched. However, it doesn't clarify what 'can be opened' means (HTTP status, syntax, reachability) or whether any network request occurs, leaving a clear gap for a side-effect-bearing check.

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

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

Two short sentences with the primary action first and the key exception second. There is no filler, and the front-loaded structure makes it easy to scan.

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

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

Despite rich per-parameter schema descriptions, the overall tool description is too thin for a 9-parameter tool with no output schema and no annotations. It does not specify what result is returned, how to interpret 'ok,' or how the many optional parameters relate to the stated URL-checking purpose.

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

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

Schema description coverage is 100%, so the parameters are already well documented in the input schema. The description adds no parameter-specific meaning beyond that, which meets the baseline but doesn't elevate it.

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

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

Description states a clear verb and resource: check whether a URL can be opened. It also provides a distinguishing behavioral note ('No browser is launched') that helps set it apart from browser-url-ok, though it doesn't fully differentiate it from other URL-checking siblings like fetch-status or web-fetch.

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

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

The note that no browser is launched implies a lightweight check and hints at not using this when a real browser interaction is needed, but it doesn't explicitly state when to choose this tool over alternatives. No sibling names are mentioned, so an agent must infer usage context from the 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, the description must carry the behavioral burden. It does disclose that the query is discarded, which is useful privacy-relevant behavior. However, it does not state the return format, possible side effects, error behavior, or how the many other schema parameters are handled beyond their own schema descriptions.

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

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

The description is two short sentences with no filler. The primary action is front-loaded, and the second sentence adds meaningful behavioral information without redundancy.

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

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

For a simple length-checking tool, the description plus schema is mostly sufficient: an agent can infer that `query` is the search text. However, all nine parameters are optional, and neither the description nor the schema clarifies what happens when no query is provided or what the exact return value looks like, especially with no output schema 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 does not explicitly name the `query` parameter, but the schema's `query` description closely matches the tool intent. The description adds no extra guidance about which of the nine optional fields to populate or that most are irrelevant to this tool.

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

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

The description clearly states the verb ('Count'), the resource ('characters in a search query'), and that the query is discarded. This differentiates it from sibling tools like domain-shape or normalize-url by naming a specific counting operation, though it does not explicitly contrast with a sibling.

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

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

No usage context or alternatives are mentioned. The phrase 'search query' implies when the tool might be used, but there is no guidance about when not to use it, what prerequisites exist, or how it relates to other similar count/shape 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 carry the full behavioral burden. It does not disclose whether the tool returns a single code, a list, a mapping, or performs network lookups; the parameter notes like 'discarded after the shape check' hint at side-effect-free behavior but are not organized into a coherent behavioral model.

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, but brevity is not conciseness; the sentence omits the essential action and is misleading relative to the schema. It does not front-load a clear verb or resource.

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?

A tool with 8 heterogeneous parameters, no output schema, and no annotations needs a much richer description to be callable. The current definition gives no indication of expected output, how inputs are used, or which inputs are required, so an agent cannot reliably select or invoke it.

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 describes all 8 parameters individually (e.g., 'City name for a public weather hint; discarded after the call'), but these descriptions are disconnected from the tool description; they suggest the tool acts as a generic shape-checker or normalizer rather than a status-code catalog. Schema coverage is high, but the tool description does not help reconcile the mismatch, so the value is limited.

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

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

The description 'Short catalog of common HTTP status codes' is a noun phrase, not a verb phrase; it never states what the tool actually does (retrieve a code, validate a response, map inputs to codes?). The input schema clashes with the description: parameters like city, feed, and json have no obvious relation to HTTP status codes, so an agent cannot infer the tool's purpose.

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

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

No when-to-use guidance, no alternatives mentioned, and no context on when status-catalog should be chosen over sibling tools like fetch-status or web-fetch. The description implies it is a static reference, but nothing clarifies its role in a workflow.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose that the prompt is discarded and that a template is returned, which are useful. But it fails to state that all parameters are optional or ignored, nor does it describe any potential side effects or the static nature of the template.

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

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

The description is two brief sentences, front-loaded with the return value and followed by an explicit behavioral note. Every word earns its place with no redundancy.

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

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

The tool has 9 optional parameters and no output schema or annotations, yet the description gives only a high-level purpose. It does not explain why the parameters exist, when to use the tool relative to siblings, or what the template contains. An agent would be left guessing about invocation 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?

All nine parameters already have detailed descriptions in the schema, so the baseline is 3. The description's 'Prompt discarded' adds a general statement that input is ignored, which is useful but does not explain individual 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 specific action and resource: 'Return a three-step thinking template.' The phrase 'Prompt discarded' clarifies it does not process input, making its function clear. However, it does not refer to any sibling tool, so it lacks explicit 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?

No guidance is given on when to use this tool instead of the many sibling tools. There is no mention of alternatives or conditions. The only contextual hint is 'Prompt discarded', which is a behavior, not a usage recommendation.

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, but it only says 'current time' and does not state whether the call is read-only, requires network access, has side effects, or what the response contains. Some parameter descriptions mention values being discarded, but the main description adds almost no behavioral detail.

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, front-loaded sentence with no filler. It is under-specified for a tool with nine parameters and no annotations, so the brevity is not fully appropriate.

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 far too sparse for a tool with nine parameters, no annotations, and no output schema. It does not explain the input contract, the output format, or the relationship between the description and the schema.

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 high description coverage, but none of the parameters (ref, url, city, feed, host, json, path) corresponds to an IANA timezone, and the tool description does not map to any parameter. An agent cannot determine how to specify the timezone, making the schema actively misleading for this tool.

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

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

The description states a clear purpose: returning the current time for a named IANA timezone, and it distinguishes the tool from siblings like utc-time and iana-zones. However, it is phrased as a noun phrase rather than an explicit verbed action, and it leaves how the timezone is specified entirely to 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?

There is no guidance on when to use this tool versus alternatives, no exclusions, and no context beyond the implied use case of needing the current time in an IANA zone. Sibling tools such as utc-time and iana-zones are not 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 burden. It does not disclose that the input parameters are discarded or ignored, nor does it describe output format, side effects, or read-only behavior. The schema hints at discarded values, but the description itself remains silent on these important traits.

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, fluff-free sentence with no wasted words. It is concise, but the terseness borders on under-specification rather than efficient enrichment.

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

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

Given seven input parameters, no annotations, and no output schema, the description is incomplete. It does not state that all parameters are discarded, does not explain the timestamp format, and gives no hint about when to prefer this over sibling time-related tools.

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

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

All seven parameters have individual schema descriptions, so schema coverage is high. However, the tool description adds no parameter-related meaning and fails to mention that all inputs are effectively irrelevant to the returned timestamp. The baseline of 3 applies because the schema already documents 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 'Current UTC timestamp' essentially restates the tool name 'utc-time'. It names the output, but provides no verb or resource distinction, and does not help an agent differentiate it 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?

There is no guidance on when to use this tool instead of alternatives. No context is given about choosing it over 'timezone', 'iana-zones', or any other sibling, and no exclusions or prerequisites 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?

The description discloses a non-obvious behavior: 'The body is discarded', implying no retention. It also frames the operation as a check, which is useful because no annotations are present. However, it does not explain return values, error behavior, or what happens with invalid JSON, so the behavioral coverage 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?

The description is two brief, purposeful sentences with no redundant filler. The core validation purpose is front-loaded, and the disposal side effect is stated 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?

Despite a seven-parameter schema, the description does not map 'body' to the 'json' parameter or clarify what a caller should pass. Without an output schema, it also omits the response format for valid versus invalid JSON. The description is too sparse to be complete for this tool's complexity.

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

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

The schema already documents every parameter, including 'json' as the JSON text to validate, so the description adds little semantic value. The term 'body' in the description is ambiguous relative to the schema's parameter names and requires inference. Baseline 3 applies because the schema carries most of the parameter-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 states a specific validation action: 'Check whether a body is valid JSON' and clarifies the body is discarded. It clearly identifies the resource being validated and is not a tautology. It does not explicitly differentiate from sibling shape-checking tools, so it stops short of a 5.

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

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

No guidance is given about when to use validate-json versus sibling tools like domain-shape or file-path-ok. It does not state conditions, exclusions, alternatives, or when not to use this tool. The only usage cue is implicit in the tool's 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only mentions the Open-Meteo source and does not state that city is the only relevant parameter, whether the call is read-only, how failures are handled, or what is returned if the city is unknown.

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

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

The description is a single concise sentence with no filler or redundancy. It is front-loaded with the core purpose and names the data source 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?

Despite a simple stated purpose, the tool has 9 optional parameters, no output schema, and no annotations. The description does not explain why so many unrelated parameters exist, what the response format looks like, or that city is the only operative input, leaving the agent under-informed.

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 semantic detail beyond the schema, and only city is directly relevant to the stated purpose, while the schema already explains that other parameters 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 states a clear purpose: returning the current temperature for a city via a named data source (Open-Meteo). It is specific enough to distinguish from most sibling tools, though it does not explicitly contrast with any weather-related 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?

No guidance is provided about when to use this tool instead of siblings like geo-hint, web-fetch, or utc-time. There are no exclusions, prerequisites, or alternative-seeking signals in the description.

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

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

With no annotations, the description carries the burden of disclosing behavior. It does disclose the important fact that the body is discarded, but it remains silent on other behavioral details such as request method, redirects, timeouts, errors, or the fact that many schema parameters appear to be discarded after shape checks.

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 front-load the core output and then state the key discard behavior. There is no filler or redundancy.

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

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

For a tool with nine optional parameters, no output schema, and no annotations, this description is under-specified. It does not identify which parameter supplies the URL, describe the response format, or clarify how the other parameters are meant to be used, so an agent would have to rely heavily on schema descriptions and guesswork.

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. The description adds no parameter-specific meaning and does not explain how the unrelated parameters relate to the stated URL-fetch purpose, leaving the agent to infer which parameter is actually 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 description clearly states the tool returns HTTP status and content type for a public URL and explicitly says the body is discarded. It is specific about the scope, but it lacks a verb and does not distinguish itself from siblings 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?

It provides some context: the tool is for public URLs and returns only status/content type, so an agent should not expect body content. However, it does not name alternatives or give explicit when-to-use versus when-not-to-use guidance against 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?

The description reveals one behavioral trait — the title is discarded after the call — but annotations are absent, so the description should carry more burden. It does not disclose return shape, network access, error behavior, or whether any other input fields are used.

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

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

The description is one short sentence with no filler and front-loads the core action. It is economical, though it omits 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?

For a tool with no output schema and an eight-parameter schema that does not obviously match the purpose, the description is drastically incomplete. An agent cannot correctly invoke it without guessing which parameter carries the Wikipedia title.

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 documents all eight parameters, but their meanings are unrelated to the described purpose (e.g., ref is a Git ref, city is a weather hint, feed is an RSS URL). The description adds no mapping from any parameter to the Wikipedia title, so a caller cannot determine which field should hold the title.

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 — check whether a Wikipedia title exists — which distinguishes it from sibling OK/shape tools. However, the input schema has no 'title' parameter, so the stated purpose is not clearly connected to any actual input, which slightly undermines 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 about when to use this tool vs alternatives such as normalize-url, validate-json, or other *-ok checks. The description gives no conditions, prerequisites, or exclusions for invoking this tool.

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