ISO country MM

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 'Task text discarded' and that the tool returns specific artifacts, which is useful. However, it doesn't mention potential costs despite 'pay-per-call', network behavior of 'remote MCP hops', or any side effects or auth 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 short and front-loaded with the primary purpose, and every sentence adds information. The unexplained 'Monid' parenthetical and slightly vague 'remote MCP hops' prevent a 5, but overall it is efficient and readable.

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

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

The tool has 9 optional parameters, no output schema, and no annotations, yet the description doesn't explain which parameters to supply, what a successful result looks like, or how the returned artifacts are structured. The complexity of the schema plus the lack of usage guidance leaves an agent under-equipped to invoke 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%, so the input schema already documents all 9 parameters. The description adds no parameter-specific meaning beyond the schema, which is acceptable given the full coverage. The 'Task text discarded' note is a general behavioral hint rather than parameter documentation.

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 ('Find') and a specific resource ('public pay-per-call tool gateway (Monid)'), and lists what it returns: CLI setup, how-it-works, skill file, and remote MCP hops. This clearly distinguishes it from the more generic sibling tools like web-fetch and fetch-status. However, 'Monid' is unexplained and the overall relationship to the agent-tool-index name remains somewhat opaque, preventing a perfect score.

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 versus alternatives. It doesn't mention conditions, exclusions, or sibling tools that might be more appropriate. The only implicit hint is that you should use it when looking for a Monid gateway, which is too narrow to count as real usage guidance.

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

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

With no annotations provided, the description must disclose behavioral traits, but it only mentions that no browser is launched. It does not say whether the tool performs a network request, what it returns, how errors are handled, or whether it has side effects. This is insufficient for an agent to predict the tool's behavior confidently.

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 main purpose comes first, and the important behavioral caveat 'No browser is launched' is included immediately after. 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?

This tool has 9 optional parameters, no output schema, and no annotations, but the description provides only a two-sentence summary. It does not explain return values, error behavior, network implications, or which parameters are relevant to the URL-open check, leaving significant ambiguity 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 the baseline is 3; the tool description adds no parameter-level meaning beyond the schema. While the parameter descriptions are detailed, the overall tool description does not clarify which parameters actually drive the 'can be opened' 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 clearly identifies the action: check whether a URL can be opened, with the specific qualifier that no browser is launched. This distinguishes it from browser-based tools like playwright-url-ok, though it does not name alternatives explicitly.

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 check is desired, but the description does not explicitly say when to choose this tool over siblings like playwright-url-ok, normalize-url, or web-fetch. Usage context is implicit, not direct.

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. 'Expression discarded' discloses that input is not retained, but it does not say whether a result is returned, what the output is, or whether there are side effects. This is too little behavioral context for a tool with no annotations.

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

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

The description is only two short, direct sentences with no filler, and the core verb is front-loaded. It is concise, though its brevity creates the under-specification penalized elsewhere.

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

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

For a tool with 9 optional parameters, no output schema, no annotations, and many sibling alternatives, the description is not complete enough. It omits the return behavior and the parameter-to-expression mapping that an agent needs to call the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3 even without parameter information in the description. However, the description adds nothing to link the nine schema parameters to the arithmetic expression, leaving real uncertainty about how to invoke the 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 names a specific operation ('Evaluate a+b style arithmetic'), which gives some idea of the tool's purpose. But it does not identify which schema parameter carries the expression, what the result is, or how this differs from the many sibling shape-check tools, so the purpose remains vague.

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

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

There is no guidance on when to use calc-eval versus visible alternatives like validate-json or the various shape-check tools. No when, when-not, or alternative routing 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, the description carries the full burden of behavioral disclosure. It adds one useful detail: 'Page content is not stored.' However, it does not disclose network access behavior, error handling, rate limits, authentication needs, or side effects of fetching the URL, leaving significant behavioral ambiguity for a tool that likely makes external requests.

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 and front-loaded with the core behavior. Both sentences earn their place, though the extreme brevity leaves material gaps in usage and behavioral guidance, so it is not fully 'appropriately sized' for a tool with a large optional parameter set and no annotations.

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 lack of annotations, an output schema, and a large overlapping sibling set, the description is incomplete. It does not explain which parameter is primary, how results are returned, how invalid URLs are handled, or why many unrelated parameters are accepted, making it hard for an agent to reliably select and 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 high, so the baseline is 3 even without top-level parameter details. However, the description adds little beyond the schema, and the schema contains many loosely related parameters (ref, url, city, feed, host, json, path) whose connection to URL citation is unclear; the path description also appears mislabeled as 'Public hostname.'

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: returning host, scheme, and HTTP status for a URL. This makes the primary function understandable, but it does not explicitly differentiate the tool from siblings like fetch-status or normalize-url, which likely overlap in scope.

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

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

There is no guidance on when to use this tool versus alternatives, no exclusion criteria, and no mention of which sibling tools cover similar cases. The description only states what the tool does, not when to choose it.

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

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

With no annotations, the description carries the full burden of disclosing behavior. It does add a meaningful privacy guarantee ('No identifiers are retained') and the schema descriptions reinforce that values are discarded after checks. However, it does not disclose what the classification output looks like, whether any external network activity occurs, or whether the operation has side effects beyond 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 concise: two short sentences with no redundant wording. The main action is front-loaded in the first sentence, and the privacy note is delivered efficiently in the second. It could earn a 5 if the first sentence were more informative about the classification output.

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 optional parameters, no annotations, and no output schema, the description is too incomplete for an agent to know how to invoke this tool correctly. It lacks the classification categories, required versus optional inputs, and expected response format. The privacy note is useful but does not compensate for the missing operational context.

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

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

Schema description coverage is 100%, so the baseline is 3 because each parameter is already documented with its purpose and discard behavior. The description adds only a general privacy statement rather than any parameter-specific semantics, which is acceptable given the 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 says 'Show how this request is classified', which provides a verb and object but leaves the classification scheme undefined. It does not distinguish this tool from the many sibling tools that also inspect URLs, refs, paths, or other inputs. The tool name 'compatibility' hints at the purpose but the description never explains what compatibility is being assessed against.

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 normalize-url, validate-json, or geo-hint. The privacy statement 'No identifiers are retained' suggests it is safe, but it does not state which inputs are expected, whether one field or many should be supplied, or what kind of request should be routed here.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only reveals that the tool avoids WHOIS/ownership data; it does not state whether inputs are validated, what happens to the many discarded fields, whether there are side effects, or what the output shape looks like. The schema descriptions mention 'discarded' behavior, but the main description itself is behaviorally thin.

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

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

The description is a single, front-loaded sentence with no filler. It states the core operation and one key limitation efficiently. It could add more context, but as a concise statement of purpose it 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?

This tool has 9 optional parameters, no required fields, no output schema, and no annotations, yet the description only addresses hostname splitting. An agent cannot determine what the other parameters do, whether they are valid inputs for this tool, what the tool returns, or how to invoke it correctly for anything beyond a simple hostname. This is a serious completeness gap.

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

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

Schema description coverage is 100%, so the baseline is 3 even with no parameter detail in the description. Each parameter has a meaningful explanation in the schema. However, the main description does not help reconcile why 'domain-shape' accepts city, feed, json, path, zone, and query in addition to host, leaving the mapping between purpose and parameters unclear.

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

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

The description uses a specific verb and resource: 'Split a hostname into labels' and adds a clear exclusion, 'without WHOIS or ownership data.' This distinguishes it from ownership-oriented domain tools and from sibling shape tools like github-repo-shape or jira-key-shape. However, it does not acknowledge the 9-parameter schema, which includes many unrelated fields, so the stated purpose feels narrower than the actual input surface.

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

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

There is no explicit guidance on when to use this tool versus alternatives such as normalize-url, browser-url-ok, or github-repo-shape. The phrase 'without WHOIS or ownership data' implies a non-ownership use case, but it does not state when the tool is appropriate, what prerequisites exist, or which sibling tools should be used instead.

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 behavioral burden. It does disclose meaningful traits: HEAD semantics (no body fetched), status-only result, and restriction to public URLs. However, it omits return format, timeout/error behavior, and redirect handling, and there is no output schema to compensate.

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?

Eight words in a single sentence, with scope front-loaded: HEAD, public URL, status only. Every token earns its place and there is zero 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 9 parameters, no annotations, and no output schema, a one-sentence description that never identifies which parameter is the target URL is radically inadequate. The agent must guess among url/feed/host, and phrases like 'discarded after the shape check' suggest the schema was merged in from a different tool. A correct call cannot be reliably assembled.

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 belong to other tools — ref (Git ref), city (weather hint), json (JSON validation), zone (IANA timezone), query (search text) — none of which support 'HEAD a public URL.' Even the url parameter is described as 'to normalize or cite,' matching normalize-url rather than this tool. The schema semantics actively mislead, so the 100% coverage baseline does not apply.

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 precise operation: HEAD (HTTP method), a public URL, and the exact result ('status only'). This clearly distinguishes it from content-returning siblings like web-fetch and browser-based checks like browser-url-ok/playwright-url-ok, so an agent understands this is a lightweight liveness probe without opening any schema.

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

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

No explicit when-to-use guidance or named alternatives appear in the description. 'Status only' implies the lightweight health-check use case, but with five-plus URL-related siblings (web-fetch, normalize-url, browser-url-ok, playwright-url-ok, inspect-robots) the agent receives no routing direction. The usage context is implicit rather than stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only reveals that the path is discarded; it does not state whether the URL is validated, normalized, fetched, or transformed, nor what the tool returns or whether any external access is involved.

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

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

The description is two short sentences with no redundant wording. The core action is front-loaded, and the 'Path discarded' note adds useful behavioral information without padding.

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, zero required fields, no output schema, and no annotations, the description is far too sparse for reliable invocation. It does not explain which parameter carries the Figma URL, why the other parameters exist, or what successful output looks like.

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 meaning. The description does not indicate which of the nine schema properties is the Figma URL or whether the others should be ignored, but the schema itself provides complete parameter documentation.

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

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

The description states a specific action ('Parse') and a specific resource ('a Figma file URL'), and adds a clarifying note that the path is discarded. This makes the tool's domain clear and distinct from siblings like normalize-url or github-repo-shape, though it stops short of explaining what 'shape' means or what the parse result is.

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: use this tool when a Figma file URL needs to be parsed. However, there is no explicit when-not-to-use guidance, no mention of alternatives, and no context about whether this should be preferred over browser-url-ok, normalize-url, 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 must carry behavioral disclosure; 'No disk access' is a meaningful behavioral guarantee. However, it does not disclose the return type/format, what 'safe' encompasses (traversal, absolute vs relative, existence), or what happens if unrelated schema fields are supplied.

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 and the key behavioral constraint are front-loaded. 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?

Despite having no output schema and no annotations, the description does not explain the return value, the definition of 'safe', or how to interpret the large optional parameter set. For a 9-parameter tool with many siblings, this is materially incomplete.

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

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

Schema description coverage is 100%, so the baseline is 3; the schema already documents 'File path to check' and the other eight optional fields. The description adds no extra parameter guidance, and the presence of nine loosely related optional parameters could confuse an agent, but the schema itself covers each field.

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

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

The description uses a clear verb-resource pair ('Check whether a path looks safe') and adds a meaningful scoping constraint ('No disk access'), which distinguishes it from I/O-based checks. It is slightly vague about what 'safe' means, and it does not explicitly differentiate itself from sibling path/name/domain shape 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?

There is no guidance about when to prefer this tool over the many sibling tools (browser-url-ok, domain-shape, normalize-url, etc.) or when not to use it. 'No disk access' implies a use case, but the description never states conditions or exclusions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It mentions the external service and output but does not disclose that this is likely a network call, that all parameters are optional, that several values are discarded, or what happens on failure or empty input.

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 service and result are front-loaded. It is compact and easy to scan, though its brevity contributes to the overall incompleteness.

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 required fields, no annotations, and no output schema, one sentence is grossly insufficient. The agent cannot determine which parameter to populate, what the response contains, or how this tool differs from the many sibling validation and hint tools.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description adds no parameter-level meaning. The description does not help the agent map 'place' to any specific parameter, leaving room for confusion among the nine optional 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 states a specific output (latitude and longitude) and a service (Open-Meteo), but it reads as a noun phrase rather than a clear verb phrase like 'Get'. It also does not identify which of the nine schema parameters represents the 'place', so the agent cannot reliably infer the actual call shape.

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 or alternatives are mentioned. The description provides only a weak implication that the tool is for geocoding, and it does not distinguish this tool from sibling tools such as weather-hint or timezone.

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 and no output schema, the description carries the behavioral burden: it correctly indicates a parse/transform operation and a GitHub URL input. However, it does not disclose the return shape, invalid-URL behavior, or confirm that only the `url` parameter is relevant. There is no contradiction with annotations because no annotations exist.

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

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

The description is a single front-loaded sentence with no filler: it names the verb, the resource, and the input domain. Every word contributes to the meaning, and it is appropriately sized for a simple parse tool.

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

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

For a tool with many optional parameters and no required ones, the description plus schema leaves real ambiguity about which parameter to populate and what the tool returns. The `url` parameter description, 'HTTPS URL to normalize or cite,' does not clearly identify it as the required GitHub URL. An output schema or a sentence naming the `url` parameter and the returned owner/repo fields would be needed.

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

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

The schema provides 100% per-parameter descriptions, so the baseline is 3. The main description adds the important 'GitHub' qualifier, but it never names which parameter should hold the URL, forcing the agent to infer `url` from its name. The many discard-after-use parameters are individually described but not related to the GitHub-repo 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 specific operation ('Parse owner and repo') and a specific resource ('a GitHub URL'), so an agent can tell this tool extracts GitHub repository identity. It is not tautological and is reasonably distinguishable from siblings like normalize-url or domain-shape. However, it does not explicitly contrast itself with those siblings, 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?

There is no guidance on when to use this tool versus alternatives such as normalize-url, domain-shape, or figma-url-shape. The description implies 'use when you need owner/repo from a GitHub URL,' but it does not state when not to use it, prerequisites, or fallback options. This leaves the agent to infer the selection criteria.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals one trait ('Titles discarded') and that the data is 'current', but it does not state network access, output shape, or any side-effect safety. This is minimal 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?

Two short sentences, with the core action first and the output-shaping note second. No filler or repetition; 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 simple count operation with no required parameters, the description is nearly sufficient, but it leaves open which optional fields apply, if any, and does not explicitly state the return type beyond 'count'. Given the 9-parameter generic schema and the absence of output schema and annotations, a bit more guidance would make it solid.

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 9 parameters already have descriptions in the schema, so the description does not need to re-document them. However, the tool description does not tie any parameter, such as 'feed', to the operation, so it adds no semantic value beyond the schema.

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

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

The description names a specific verb and resource: count current Hacker News front-page stories. 'Titles discarded' clarifies that the result is a count, not the stories. No sibling tool advertises this behavior, so it is distinguishable.

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 of when to use this tool versus any alternative, and no mention of whether a feed or URL should be supplied. The tool is implicitly selected by an HN-front-page request, but the description gives no explicit trigger, prerequisites, or exclusions.

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

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

No annotations are present, so the description carries full responsibility for behavioral disclosure. It says nothing about return values, side effects, error conditions, or why the nine optional parameters exist. The description provides no information beyond the tool's nominal subject.

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

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

The description is a single short sentence, but this is under-specification rather than effective conciseness. It omits all operational detail and does not front-load any actionable information. Every word is generic.

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, a one-line description is completely inadequate. There is no explanation of what the tool returns, how the parameters relate to timezone names, or what the caller should expect.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description adds no parameter-specific context. The schema already documents each parameter, including discard behavior, so the lack of description-level parameter guidance is partially mitigated.

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

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

The description is a noun phrase ('Common IANA timezone names for clock calls') with no verb indicating what the tool actually does (e.g., return, validate, list). It identifies a resource and a vague purpose but does not clearly state an action, making it hard for an agent to know what invocation would achieve.

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 like 'timezone' or 'utc-time'. The only hint is 'for clock calls', which is too generic to distinguish from sibling tools. No exclusions or alternative tool mentions 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 must carry the behavioral disclosure burden. It clearly indicates a read-only network fetch and that only counts are returned, but it does not describe failure modes, missing robots.txt handling, rate limits, or what exactly constitutes a 'group'.

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

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

The description is a single front-loaded sentence with no filler. It communicates the action, resource, and output scope efficiently.

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

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

Given nine optional parameters, no output schema, and no annotations, the description is insufficient for reliable invocation. The critical missing context is which parameters to supply and what the returned group counts actually look like.

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 adds no mapping between its purpose and the correct parameter. With both 'url' and 'host' present in the schema, an agent cannot confidently determine which input identifies the robots.txt to inspect.

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

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

The description states a clear action and resource: fetch a public robots.txt. It also specifies the output scope ('group counts only'), which helps distinguish it from general fetch tools. It falls just short of a 5 because 'group counts' is not explicitly defined and no alternative sibling is named.

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

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

No guidance is provided for when to use inspect-robots instead of alternatives such as web-fetch or fetch-status. There are no exclusion criteria or conditions, leaving the agent to infer when this tool is appropriate.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does add one behavioral note—'Key discarded'—but it does not explain what happens on success/failure, what the return value is, or what 'discarded' means in terms of data handling.

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

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

The description is only two short sentences and is front-loaded with the primary purpose. No words are wasted, and 'Key discarded' adds a behavioral hint without bloat, though it is cryptic.

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

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

This is a tool with no annotations, no output schema, and seven potentially confusing parameters. The description is far too sparse to be complete; it omits the input-to-parameter mapping, the output shape, and usage context, all of which are needed 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?

All seven schema properties have descriptions, so the baseline is 3, but the description never maps the 'Jira issue key' to any of them. The schema contains ref, url, city, feed, host, json, and path—none obviously a Jira key—and the description does not resolve which parameter should contain the key, leaving the agent guessing.

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 ('Check') and resource ('Jira issue key shape'), and the sibling tool names make the differentiation from other shape-checkers (domain-shape, github-repo-shape) clear. However, it does not give an example shape (e.g., PROJ-123) or identify which input parameter carries the Jira key, which is a small but real gap.

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

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

No guidance is given about when to use this tool versus alternatives like github-repo-shape or wiki-title-ok. The intended use is only implied by the tool name and the phrase 'check a Jira issue key shape', not explicitly stated.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose one important behavior: the body is discarded. However, it does not mention whether the tool follows redirects, handles network errors/timeouts, requires authentication, or has rate limits, and it does not explicitly state the response format beyond 'HTTP status'.

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. 'Body discarded' is a meaningful behavioral constraint, and the core operation is front-loaded. 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 optional parameters, no output schema, and no annotations, the description is too thin. It does not explain what happens when different parameter types are passed, which parameters are needed for the docs-URL use case, what 'hint' means operationally, or what the actual response looks like beyond 'HTTP status'.

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

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

Schema description coverage is 100%, and each of the 9 parameters has its own description, so the baseline of 3 applies. The tool description adds no parameter-level meaning and does not reconcile its URL-only framing with the schema's city, feed, json, zone, and query parameters, which could confuse an agent about which parameters are relevant for the stated 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 specific operation ('HTTP status') and a specific resource ('public library docs URL'), so an agent can understand the core purpose without opening the schema. It does not explicitly differentiate from sibling tools like fetch-status or web-fetch, but 'lib-docs-hint' and 'Body discarded' make the intended scope reasonably clear.

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

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

There is no explicit guidance about when to use this tool versus alternatives such as fetch-status, web-fetch, or browser-url-ok. 'Body discarded' weakly implies that this tool is only useful when the body is not needed, but no alternative tool is named and no selection criteria are given.

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. 'Values discarded' hints that only keys matter, but it does not disclose whether the count is top-level only or recursive, how invalid JSON is handled, what output is returned, or whether any state is retained. This is minimal for a tool with no annotations.

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

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

The description is two short sentences with the action front-loaded and zero filler. Every word earns its place, and the key behavioral point ('Values discarded') is included 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 no-annotation, no-output-schema tool with nine parameters, two sentences are insufficient. It does not specify which parameter is the JSON input, whether the count includes nested keys, what the return value looks like, or how errors are surfaced. The agent is left with too much ambiguity to confidently 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?

Although schema coverage is 100%, the description does not identify which of the nine string parameters should contain the JSON object. The schema's 'json' parameter is described as 'JSON text to validate', while the tool description says to count keys, creating a conflicting semantic signal. The description adds no parameter-level clarity.

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

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

The description clearly states a specific action ('Count keys') on a specific resource ('a JSON object'), and adds that values are discarded. This distinguishes it from generic validation tools like validate-json, though it does not explicitly name alternatives or clarify which parameter is 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 instead of siblings. There are no alternatives mentioned, no exclusions, and no context to help an agent decide between memory-key-count and related JSON/shape tools. An agent would have to infer usage from the name and description alone.

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

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

With no annotations, the description carries the full burden, and it does disclose a meaningful behavior: query and fragment are dropped. However, it does not clarify what happens with invalid URLs, whether the output is a string or object, or why the schema contains many seemingly unrelated parameters.

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

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

Two short, front-loaded sentences with no filler: the return value is stated first, then the drop behavior. Every word contributes meaning.

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

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

The core behavior is described, but the definition is incomplete in context: no output schema, no annotations, and a 9-parameter schema full of unrelated fields such as city, feed, json, and zone. An agent cannot confidently determine which parameters are relevant or what output shape to expect.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description adds minimal parameter-level detail. The description points to 'a URL,' and the schema already identifies the url parameter as the HTTPS URL to normalize, but neither clarifies how the eight other optional parameters should be handled.

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

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

The description clearly states what the tool does: it returns origin, host, and path for a URL, and drops query and fragment. It is specific about the resource and behavior, though it does not explicitly differentiate itself from sibling URL-related tools like browser-url-ok or figma-url-shape.

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 exclusions, and no mention of prerequisites. The only usage signal is implied by the description itself.

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 only that no browser is launched, but does not explain what 'can be opened' means, whether a network request is made, what the return value looks like, or what side effects may occur.

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

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

The description is very concise and front-loaded, with no filler. Both sentences earn their place, though the brevity leaves important behavioral details unstated.

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 annotations, and no output schema, so the description is too thin to fully orient an agent. It does not explain the purpose of the non-URL parameters, the success criteria, or the output 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?

Schema description coverage is 100%, so the baseline is 3 even without additional parameter detail in the description. The description adds no meaningful parameter semantics beyond the word 'URL', and the schema's own 'url' description mentions 'normalize or cite' rather than 'open', creating mild ambiguity.

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

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

The description states a clear verb ('Check') and resource ('whether a URL can be opened'). The added 'No browser is launched' distinguishes it from browser-based tools, but 'can be opened' is ambiguous about whether this means URL syntax validity, DNS resolution, or HTTP reachability.

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 this is a lightweight URL check suitable when a browser is not needed, but it does not explicitly name alternatives like browser-url-ok or fetch-status, nor does it say when to prefer this tool over them.

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

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

There are no annotations, so the description must carry the transparency burden. It does disclose one behavioral trait beyond the schema—'Query discarded' indicates the input is not retained. However, it does not mention return behavior, side effects, or how multiple provided parameters are treated.

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

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

Two short sentences with no filler; the main purpose is front-loaded and the data-handling note ('Query discarded') earns its place. This is appropriately concise for a simple length-counting tool.

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

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

For a 9-parameter tool with no annotations and no output schema, the description is too sparse: it does not state what the tool returns, how character counting is defined, or whether only the query parameter is used. The discarded note helps but leaves important invocation and output behavior unclear.

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 tool description adds little parameter detail. The phrase 'search query' maps naturally to the query parameter, but the description does not clarify that the other 8 optional parameters 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 names a clear verb ('Count') and a resource ('characters in a search query'), so an agent can understand the core operation immediately. It does not explicitly distinguish itself from sibling count/shape tools, but the search-query object is specific enough to avoid serious ambiguity.

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

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

The directive 'Count characters in a search query' implies when the tool should be used, but there is no explicit when-to-use/when-not-to-use guidance or mention of alternatives. With 9 optional parameters and many sibling tools, an agent gets only an implicit usage cue.

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 says nothing about side effects, return values, input handling, or the fact that several parameters are explicitly discarded; the 'discarded' hints live only in the schema, not 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 text is short but under-specified, not genuinely concise in a helpful way. It is a single trailing phrase with no structure and no operational detail, so brevity comes at the expense of clarity.

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

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

The tool has eight heterogeneous parameters and no output schema or annotations, yet the description only states a vague subject. An agent cannot determine what inputs are required, how they are used, or what the tool returns.

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?

Every parameter has a meaningful schema description with coverage near 100%, so the baseline is 3 even though the description adds no parameter-level meaning. The description itself does not explain how any parameter relates to the catalog, but the schema compensates.

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

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

The description is a noun phrase that restates the tool name ('catalog') and never states a verb or operation. It tells the agent the topic (HTTP status codes) but not whether calling the tool returns a listing, checks an input, or maps a parameter to a 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 guidance on when to use this tool versus siblings like fetch-status, domain-shape, or validate-json. No exclusions, alternatives, or usage conditions are mentioned.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does usefully reveal that the prompt is discarded, but it does not clarify whether input parameters are ignored, whether validation happens, or what the returned template contains. Conflicting parameter descriptions in the schema (e.g., url suggested for normalization/citation) further muddy the 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?

At just two short sentences, the description is extremely concise and front-loaded with the primary action. Every word earns its place; however, the terseness borders on under-specification, which slightly limits its usefulness.

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

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

Given nine parameters, no annotations, and no output schema, this description is incomplete. It fails to explain the purpose of the parameters, what the three-step template looks like, or when to call this tool relative to the large sibling set, leaving an agent with significant gaps in understanding.

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

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

The description adds no parameter-level meaning, but the input schema already provides 100% description coverage for all parameters, so the baseline is 3. The description's 'Prompt discarded' is generic and does not compensate for any schema gaps, but none exist.

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 ('Return a three-step thinking template') and a resource, making the core purpose clear. However, it does not explain what the three steps are or how the nine input parameters relate to the function, and it does not explicitly contrast with sibling tools, so it stops short of a 5.

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

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

There is no guidance on when to use this tool versus the many siblings, no mention of conditions, exclusions, or alternatives. The phrase 'Prompt discarded' hints at behavior but provides no direction for tool selection, leaving the agent with nothing to base a decision on.

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

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

With no annotations, the description carries the full burden and only states the basic result. It does not say what happens when no zone is supplied, whether the extra schema fields are ignored/discarded, or how invalid zones are handled. The schema's many unrelated optional parameters make this ambiguity material.

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 with no filler; the core purpose is front-loaded. This is appropriate conciseness for a simple timezone lookup.

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 rich schema with nine optional parameters, the description does not identify the relevant parameter or mention ignored/discarded inputs, and there is no output schema or annotations to compensate. An agent cannot confidently tell whether to pass zone, city, url, or none of them, especially since no parameter is required.

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

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

Schema description coverage is 100%, so the baseline is 3; the zone parameter already documents 'IANA timezone name, e.g. America/New_York'. The description itself adds no parameter-level guidance, though it could have clarified that only zone matters among the nine optional 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 the tool returns the current time for an IANA timezone, which distinguishes it from utc-time and iana-zones. It lacks an explicit verb like 'Get' or 'Return', but the purpose is still unambiguous.

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

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

The phrase 'in a named IANA timezone' implies use when a specific zone's current time is needed, but the description gives no explicit when-to-use/when-not-to-use guidance or alternatives. A model must infer the contrast with utc-time and iana-zones from sibling names only.

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 bears the burden. It discloses the core behavior (returns current UTC timestamp) but does not explain that the seven input parameters are optional/ignored; the schema descriptions, not the tool description, carry that information.

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

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

The description is extremely short and front-loaded, but it is under-specified given the seven input parameters. It reads as a one-line summary rather than a complete tool definition, so it earns a middle score.

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

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

For a simple timestamp read, the description plus schema is mostly sufficient because no parameters are required. However, the tool description does not clarify why so many parameters exist or that they are all effectively ignored, which leaves some context for an agent incomplete.

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

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

All seven parameters have descriptions in the input schema, so schema coverage is high. The tool description adds no parameter meaning, but the schema descriptions already indicate the parameters' roles (mostly discarded), making a baseline 3 appropriate.

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

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

The description states the tool returns the current UTC timestamp, a specific resource with scope (UTC). It does not explicitly name a sibling alternative, so it lacks the higher distinction level, but the meaning is unambiguous.

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

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

There is no explicit statement about when to choose this over the sibling timezone tool. Usage is only implied by the name and description: use it when the current UTC time is needed.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It does add one useful behavioral trait—the body is discarded, implying no retention or side effects—but it does not state what is returned on success/failure or whether errors are raised. This is moderate transparency, not full.

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 purpose is front-loaded and the behavioral note is concise. Every word adds value.

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

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

The tool is simple and the schema covers the input, but there is no output schema and the description does not state the return format or error behavior. The missing 'body'-to-'json' mapping also leaves the invocation slightly 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?

The schema descriptions cover all parameters, including 'json' as 'JSON text to validate; discarded after the check', so the description does not need to repeat them. However, the description's phrase 'a body' does not explicitly map to the 'json' parameter, leaving a slight semantic gap.

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

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

The description states a specific action ('Check whether') and resource ('a body is valid JSON'), which clearly identifies this as a JSON validation tool. It is readily distinguished from sibling validators like wiki-title-ok or domain-shape because it is the only one targeting JSON syntax.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention sibling tools, exclusions, prerequisites, or conditions that would route an agent here instead of another validator.

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 disclosure burden. It mentions the external source (Open-Meteo) and the result (temperature), but it does not disclose which of the nine parameters is actually used, what the response shape is, or what happens on failure or when no city is provided.

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 tight sentence with no filler. The core function is front-loaded, and the source attribution earns its place by setting expectations about an external API call.

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

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

Given no annotations, no output schema, and nine optional parameters, this one-sentence description is incomplete. It does not clarify the expected return format, how the tool behaves when no relevant parameter is supplied, or whether it performs a live network request. The schema helps with individual parameters but not with tool-level context.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters and their discard behavior. The description adds only that city is the relevant input; it does not provide additional parameter-level 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 states a specific function: returning the current temperature for a city, and names the upstream source (Open-Meteo). It is not a tautology and gives a clear sense of the tool's purpose, but it does not explicitly contrast it with sibling tools like geo-hint.

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 a city' implies the intended usage, but there is no explicit when-to-use or when-not-to-use guidance, and no alternative tool is named. An agent can infer the use case but gets no direction about choosing this over related hint 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 openly discloses a key behavior: 'Body discarded.' This is useful beyond the tool name, especially because no annotations are present. However, it does not mention status-code semantics, redirect handling, error behavior, timeout behavior, or whether the URL is fetched directly, so the behavioral disclosure is only partial.

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

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

The description is two short sentences, front-loads the primary purpose, and the second sentence adds a non-obvious behavioral detail. There is no redundant wording or restatement of the tool name.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, this description is too thin. It does not explain which parameter contains the URL to fetch, why the other parameters exist, what the return payload looks like, or how it relates to sibling fetch/URL tools. An agent is left with a clear purpose but insufficient invocation guidance.

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. However, the schema's per-parameter descriptions—such as 'HTTPS URL to normalize or cite'—do not align cleanly with the description's fetch/status/content-type purpose, leaving some confusion about which parameter actually drives the 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 operation: report HTTP status and content type for a public URL, and explicitly notes that the body is discarded. This is a specific resource plus a specific observable outcome. It does not explicitly contrast with siblings like fetch-status or browser-url-ok, but the core intent is unambiguous.

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

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

The phrase 'for a public URL' gives only a minimal scope hint. There is no guidance about when to prefer web-fetch over sibling tools such as fetch-status, normalize-url, browser-url-ok, or playwright-url-ok, and no exclusions are stated. The description does not help an agent choose among overlapping URL-related tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does add one behavioral note ('Title discarded after the call'), but it omits other important traits such as read-only safety, return format, error behavior, or side effects, which is insufficient for a tool with no annotations.

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

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

The description is very short and to the point, with the core purpose front-loaded in the first sentence. The second sentence adds a behavioral note without becoming verbose, so the content is appropriately sized, even though it lacks necessary 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?

The tool is simple, but the description does not enable correct invocation: it never identifies the required input parameter, offers no expected output or error semantics, and the schema is partially contradictory with a required but undefined 'nickname.' With no output schema and no annotations, this is inadequate for reliable use.

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 many properties (ref, url, city, feed, host, json, path) but none is clearly identified as the Wikipedia title, and the required field 'nickname' is not even defined in the properties. The description adds no mapping between 'Wikipedia title' and any schema parameter, leaving the agent without the information needed to populate the correct argument.

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

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

The description says 'Check whether a Wikipedia title exists,' which is a specific verb and resource, and it clearly distinguishes this tool from sibling shape-checkers like file-path-ok or browser-url-ok. However, it refers to a 'Title' that does not appear in the input schema, so the mapping between the described purpose and the actual parameter is left ambiguous.

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

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

There is no guidance on when to use this tool versus alternatives, no mention of conditions, and no exclusion criteria. The description only states what the tool does, not when an agent should select it over similar validation tools.

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