ISO country EG

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 useful context by stating that task text is discarded and that the return values are setup/docs and remote MCP hops. However, it does not disclose whether the call is read-only, whether it makes network requests, or whether any costs are 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 short and front-loaded, with the key action and resource in the first sentence. The final clause, 'Task text discarded,' is concise but somewhat confusing because no parameter clearly represents task text.

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, but the description never connects those parameters to the gateway lookup or explains what inputs are needed. An agent would not know what to pass to obtain the stated returns, making the definition incomplete for practical invocation.

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

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

The schema already provides descriptions for all 9 parameters, so the baseline is 3. The description itself adds no additional meaning about the parameters and does not explain how any of them relate to finding the Monid gateway or producing the stated outputs.

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 opens with a specific verb and resource: 'Find a public pay-per-call tool gateway (Monid),' and lists concrete return values such as CLI setup, how-it-works, skill file, and remote MCP hops. It is not a tautology, but it does not name or contrast any sibling tool, and 'Monid' is left unexplained.

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

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

The description implies when to use the tool: when an agent needs the Monid gateway's setup or integration materials. However, it gives no explicit when-not-to-use guidance and names no alternatives, so the routing decision is left mostly implicit.

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

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

With no annotations provided, the description must carry the behavioral burden. It does disclose a useful trait: no browser is launched. However, it leaves ambiguous whether the check performs a network request, what side effects exist, and what the response/result indicates.

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 main purpose and then adds a key behavioral distinction. 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?

Given nine optional parameters, no output schema, and no annotations, the description is far too terse to fully guide an agent. It does not state what result indicates success, whether the check is local or network-based, or which parameters are actually meaningful for the URL check.

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

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

Schema description coverage is 100%, so the parameters are already documented in the schema. The description adds no meaning beyond the schema's own explanations and does not clarify how the many unrelated-looking parameters relate to checking whether a URL can be opened.

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: 'Check whether a URL can be opened.' It also adds the clarifying behavioral note 'No browser is launched,' which helps distinguish it from browser-launching siblings like playwright-url-ok. It is not a tautology, though it does not explicitly name sibling tools.

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

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

The description gives no explicit guidance about when to use this tool versus alternatives such as fetch-status, web-fetch, normalize-url, or playwright-url-ok. 'No browser is launched' implies a lightweight check, but no condition, exclusion, or alternative tool is stated.

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

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

With no annotations, the description carries the full disclosure burden, but it only says 'Expression discarded'—which refers to a non-existent input and does not clarify side effects, return values, errors, or what happens to the nine actual parameters. The behavioral picture is essentially absent.

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 this is under-specification rather than effective conciseness. 'Expression discarded' is cryptic and unhelpful, and the description omits critical invocation details rather than earning its brevity.

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

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

Given 9 parameters, no annotations, and no output schema, this description is far too incomplete. An agent cannot determine what input to pass, what response to expect, or whether this tool is even functional for the advertised arithmetic 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?

The schema descriptions cover all 9 parameters, so the baseline is 3, but the description adds no meaning for any of them and instead introduces a phantom 'expression' not present in the schema. This actively undermines parameter understanding rather than supplementing it.

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

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

The description claims a specific capability, 'Evaluate a+b style arithmetic', but the input schema exposes nine unrelated string parameters (ref, url, city, feed, host, json, path, query) and no expression field. This makes the stated purpose misleading rather than clarifying, and it gives no basis for an agent to distinguish this from the sibling validation/check tools.

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

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

There is no guidance on when to use calc-eval versus any of the many sibling tools, and no prerequisites or exclusions. The only implied usage trigger is arithmetic evaluation, but the schema cannot actually support that invocation, making the guidance misleading.

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, but it only says the record is 'public', hinting at accessibility without stating side effects, return behavior, or how inputs are handled. The schema mentions discarded values and no disk access, but the description itself does not disclose these behavioral 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 very short and has no wasted words, which is concise. However, it is under-specified for a tool with nine parameters and no annotations, so the brevity reduces its usefulness rather than making it appropriately sized.

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, no annotations, and many sibling tools, a one-phrase description is severely incomplete. It does not state what the tool returns, how it should be invoked, when it should be selected, or what the agent can expect from the result.

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

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

Schema description coverage is 100%, and each parameter is already described meaningfully (e.g., 'discarded after the shape check'). The description adds no parameter-level meaning, so the baseline of 3 is appropriate.

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

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

The description identifies a resource ('Public ISO 3166-1 record for EG') but lacks a verb or explicit action, so it is not clear whether the tool returns the record, validates it, or does something else. It adds some specificity over the name by referencing the ISO standard, but the purpose remains vague and does not differentiate it from sibling tools.

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

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

There is no guidance on when to use this tool versus alternatives. The sibling list contains many similar-looking tools, but the description gives no selection criteria, exclusions, or context about intended use.

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

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

With no annotations, the description carries the behavioral disclosure burden. It adds one useful behavioral fact: 'Page content is not stored.' However, it does not mention whether the tool fetches the URL, what side effects occur, failure behavior, or authentication needs, so transparency is only partial.

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

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

The description is only two sentences, front-loads the core purpose, and every sentence adds value. There is no redundant wording or filler.

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

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

The description covers the primary output and a key privacy trait, and the schema covers parameters. However, with no output schema, no annotations, and a large sibling set, the lack of usage context and return-format details leaves the tool only minimally complete.

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

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

The input schema already describes each parameter, including discard behavior for ref, city, feed, and json. The description adds no parameter-level detail beyond identifying URL as the relevant input. With high schema coverage, the baseline of 3 is appropriate.

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

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

The description clearly states a specific verb and resource: 'Return host, scheme, and HTTP status for a URL.' It is easy to understand what the tool produces. However, it does not explicitly differentiate itself from sibling tools like fetch-status or normalize-url, so it falls just 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 use this tool versus the many siblings, nor any mention of exclusions or alternatives. The phrase 'Page content is not stored' hints at a privacy characteristic but does not help an agent choose between citation, fetch-status, normalize-url, or web-fetch.

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 identifiers are not retained, which is useful, but it omits what the call does, what it returns, whether it has side effects, or how the classification is computed.

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

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

The description is very concise: two short sentences with no filler. The main action is front-loaded and the privacy note earns its place. It is too sparse to be informative, but as a matter of conciseness it is well-structured.

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, heterogeneous parameters, no output schema, no annotations, and many closely related siblings, this description is severely incomplete. An agent cannot determine what to pass, what to expect back, or when this tool is the right choice.

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 well. The description adds only the retention claim, which is already echoed in several parameter descriptions, so it provides no additional 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 uses a specific verb ('Show') and names the object ('how this request is classified'), so it is not a tautology. However, it never defines what classification scheme is used, what the output labels are, or what input should be passed, making the purpose genuinely 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 about when to call this tool versus any of the many sibling tools that perform similar-looking checks (e.g., domain-shape, validate-json, search-query-len). The privacy note is not 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, the description carries the behavioral burden. It discloses the core operation and a meaningful non-behavior (no WHOIS/ownership), but it does not state the output format, invalid-hostname handling, or the fact that most of the optional schema fields 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?

One clear, front-loaded sentence with no wasted words; the negative scope is useful and not 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?

The tool has nine optional parameters and no output schema, but the description does not identify which parameter is meaningful or what the labels look like when returned. An agent could pass the wrong parameter and not know what return 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?

The input schema has 100% description coverage and all parameters are documented, so the baseline is 3. The description only reinforces that 'host' is the relevant input without adding parameter-level detail.

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 specific resource ('a hostname'), and an explicit negative scope ('without WHOIS or ownership data'), so the agent knows exactly what the tool does and what it deliberately avoids. This distinguishes it from other shape tools like github-repo-shape or normalize-url.

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

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

The 'without WHOIS or ownership data' clause implies this is for label splitting only when ownership metadata is not needed, but no alternative tool is named and no explicit when-to-use/when-not-to-use guidance is 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?

With no annotations, the description carries the burden and does state useful behavioral facts: it uses HEAD, targets public URLs only, and avoids returning body content. Missing are redirect behavior, timeouts, error semantics, and the fact that several input values are explicitly discarded, which the schema hints at but the description does not.

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

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

The description is a single efficient sentence with no filler and front-loads the key action. It is concise, though it is arguably too terse given the tool's 9-parameter schema and lack of an output schema.

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

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

The description is incomplete for the tool as defined: it only covers the URL HEAD case while the schema shows 8 other potential input kinds, and there is no output schema or annotations to fill in behavior. An agent would not know how to use this tool for feed, host, json, path, zone, query, ref, or city inputs, nor what the returned 'status' 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 schema already explains each parameter in some detail, including discard behavior. The tool description adds no parameter-level meaning and does not connect 'HEAD a public URL' to the 'url' parameter, leaving some ambiguity about how the other eight parameters relate to 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 names a specific verb (HEAD), resource (public URL), and result (status only), so the core action is clear. It also implicitly distinguishes itself from content-fetching siblings like web-fetch and browser-url-ok. However, the input schema exposes 9 unrelated optional parameters (ref, city, feed, json, zone, etc.), which the description never acknowledges, so the full purpose is not conveyed.

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 'return status only' implies a use case: use this when you need a lightweight status check and not page content. But the description gives no explicit guidance about when to prefer this over similar sibling tools, no exclusions, and no mention of what to do when the input is not a URL.

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

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

With no annotations, the description carries the full burden of disclosing behavior. It only mentions that the path is discarded; it does not describe what parsing returns, how invalid URLs are handled, or whether any extraction or validation occurs. An agent cannot predict the tool's output or failure behavior from this text.

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

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

The description is very short and front-loaded with the main purpose, with no filler words. However, it is under-specified for a tool with 9 optional parameters, and the sentence 'Path discarded' creates ambiguity rather than adding clear, necessary 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?

The tool has 9 parameters, no required parameters, no annotations, and no output schema, yet the description does not clarify which parameter should carry the Figma URL or what the parsed result will be. The schema descriptions provide per-parameter semantics, but tool-level completeness is missing, especially for a parse operation where return value is central.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds only the 'Path discarded' note, which may clarify handling of the URL path but is not clearly tied to a specific schema parameter. The individual parameter descriptions already cover each field's disposition.

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 action and target: 'Parse a Figma file URL.' This distinguishes the tool from sibling URL-related tools like normalize-url or browser-url-ok, at least by resource type. However, it does not explain what the parse result will be, and 'Path discarded' is ambiguous about whether it refers to the URL path or the 'path' parameter.

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

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

The description implies the tool should be used when a Figma file URL needs to be parsed, which provides some usage context. It does not explicitly compare against alternatives or state when not to use this tool, so the guidance remains implicit rather than explicit.

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

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

With no annotations, the description carries the full burden. It does add one useful behavioral disclosure: 'No disk access.' But it does not explain the output type (e.g., boolean), possible errors, or whether the unrelated parameters are ignored. This leaves significant behavioral uncertainty.

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 brief and front-loaded. Both sentences earn their place: the first states the action, the second adds a key safety behavior. It is appropriately terse, though slightly under-specified for the complexity of the schema.

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

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

The tool has nine optional parameters and no output schema, yet the description does not explain how to invoke it, which parameter to use, or what the result looks like. The presence of many seemingly unrelated parameters (url, city, feed, etc.) creates ambiguity that the description does not resolve.

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

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

The input schema has 100% parameter description coverage, so the baseline is 3. The description adds no additional parameter semantics. Each schema parameter already has a description, but the tool description does not clarify that only 'path' is relevant among the nine parameters.

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

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

The description clearly states a specific action and resource: checking whether a path 'looks safe.' This distinguishes it from URL-focused siblings like browser-url-ok or normalize-url. However, 'looks safe' is somewhat vague and does not define what safety criteria are applied.

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. The description does not mention that URL checks should use sibling tools or when a path check is appropriate. There are no references to sibling tools 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the Open-Meteo dependency, but does not explain which inputs are consumed or discarded, whether this is a network call, what it returns, or how failures behave.

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. It is appropriately sized for a simple statement of purpose, though it is too terse to be fully self-sufficient.

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 nine optional parameters, no required fields, and no output schema, so the one-sentence description is not enough to guide a correct call. The agent is left uncertain about what to pass, what the response will look like, and how the parameters relate to the stated 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 coverage is 100%, so the baseline is 3 even without parameter details in the description. However, the description adds no value here: it does not map 'place' to a specific parameter such as city, nor does it clarify which of the nine optional fields should be provided.

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 communicates that the tool returns latitude and longitude for a place, and identifies Open-Meteo as the data source. It conveys the core function effectively, though it does not explicitly distinguish itself from sibling tools or say how the place should be supplied.

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 geo-hint versus alternatives like weather-hint, and no mention of prerequisites or exclusions. The only implicit usage signal is needing coordinates for a place, which is not enough to route an agent confidently.

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. 'Parse' makes the core read-only behavior clear, but the description does not disclose invalid-URL behavior, whether non-GitHub URLs are rejected, or what exactly is returned when parsing fails.

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

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

A single front-loaded sentence with no filler. The verb, target, and input type are stated immediately, and every word contributes.

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 adequate for a simple parse operation, but the schema contains many optional parameters that are never mentioned, and there is no output schema or annotation to clarify return shape and edge cases. An agent may still be unsure whether fields like `ref` or `path` are relevant to this GitHub-specific tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by identifying the `url` parameter as the GitHub URL to parse and clarifying that the expected output is owner and repo, which the generic 'HTTPS URL to normalize or cite' schema text does not convey.

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 ('owner and repo from a GitHub URL'). This clearly distinguishes the tool from sibling shape tools such as domain-shape, figma-url-shape, and jira-key-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?

The description implies when to use the tool: whenever a GitHub URL needs to be converted into owner and repo. However, it gives no explicit conditions, exclusions, or comparisons to alternatives such as normalize-url, so the agent must infer the selection logic.

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 disclose that titles are discarded, which is useful, but it does not explain whether the tool fetches live data, what the return value looks like, or any failure/rate-limit 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 only two short sentences, with the primary purpose front-loaded. There is no filler, and 'Titles discarded' is an efficient behavioral note, though it is somewhat 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?

With no output schema and no annotations, the description should explain invocation and return behavior. It does neither, and the nine optional yet seemingly unrelated parameters make it harder for an agent to know how 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 description coverage is 100%, so the baseline is 3. The description itself adds no parameter-level meaning and does not indicate which of the nine optional fields, if any, are relevant to counting Hacker News stories. The schema descriptions are self-contained but disconnected from the tool's 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 clearly states a specific action and resource: 'Count current Hacker News front-page stories.' It also adds a scope note with 'Titles discarded.' However, it does not differentiate this tool from sibling tools explicitly, 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 use this tool versus alternatives, what context to provide, or what input is needed. 'Current' implies a time-sensitive use, but no when-to-use or when-not-to-use conditions are stated.

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

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

No annotations exist, so the description carries the full disclosure burden, but it reveals no behavior at all: no mention that all parameters are discarded, no indication of what the call returns, no side-effect or usage notes. The odd discard semantics are only discoverable in the parameter schema, and the description fails to explain or even acknowledge them.

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

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

The description is a single, front-loaded sentence with zero wasted words. But it is under-specified rather than concise: 'Common IANA timezone names for clock calls' reads as a data label, not an operational description, and omits a verb and any behavioral hint despite the tool's confusing parameter surface.

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, and no output schema, this description is far from complete. The agent cannot infer what the return value is, whether it should pass any parameters at all, or why unrelated parameters are accepted and discarded. The invocation contract is left entirely to inference.

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

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

Schema description coverage is 100%, so the baseline is 3. Each parameter does have an explanatory description (e.g., 'Git ref name; discarded after the shape check'), which documents the parameter-level semantics. However, the parameters (url, city, feed, json, path) are entirely disjoint from the tool's stated purpose of timezone names, and the description adds nothing to bridge that gap or explain why an agent would pass them.

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 the subject matter ('common IANA timezone names') and its intended context ('for clock calls'), which weakly separates it from siblings like timezone and utc-time. However, it is a noun phrase with no verb: the agent cannot tell whether the tool returns a list of names, expands a zone identifier, or validates an input. The purpose is implied rather than stated.

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 versus the sibling tools timezone or utc-time, and no exclusion conditions are mentioned. The phrase 'for clock calls' hints that the output feeds into clock-related tools, but the agent is left to guess how this relates to invoking the tool.

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

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

With no annotations, the description carries the burden. It usefully discloses that the operation is public and that only group counts are returned, but it doesn't explain how the many optional inputs are processed or what happens on fetch failure. The 'only' qualifier gives some transparency about the tool's limited output.

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

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

A single, front-loaded sentence with no filler. It states the action, target, and output in a compact way.

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

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

The tool has nine optional parameters, no output schema, and no annotations, so the description needs to do more. It leaves unclear which parameter points to the robots.txt and what 'group counts only' actually returns, making correct invocation uncertain.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning: it does not clarify which of the nine optional parameters identifies the robots.txt source, and the schema descriptions are generic ('HTTPS URL to normalize or cite') rather than tied to robots.txt.

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 ('Fetch'), the resource ('a public robots.txt'), and the narrowed output ('return group counts only'). It is easy to distinguish from generic sibling tools like web-fetch, though it doesn't explicitly name any sibling or clarify which input selects the robots.txt.

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

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

The description implies the tool should be used when someone needs robots.txt group counts, but it never states when not to use it or mentions an alternative. There is no explicit routing help relative to siblings such as fetch-status or web-fetch.

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 disclosure burden. It does state that the key is discarded, which is a useful privacy-relevant detail, but it omits what counts as a valid Jira key shape, what the tool returns, and whether there are side effects. The disclosure is minimal and incomplete for a validation 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 short, front-loaded, and contains no filler; both sentences earn their place. However, the brevity borders on under-specification, so it doesn't earn a perfect score.

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

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

For a tool with seven input properties, no output schema, and no annotations, this description is far from adequate. It fails to identify which parameter to pass, what the accepted Jira key format is, what the return value looks like, or how this tool relates to siblings. The unrelated generic parameters in the schema further complicate invocation.

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

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

The schema already describes all seven parameters, so the baseline is arguably 3, but the description undermines that by talking about a 'Jira issue key' while no schema property matches that concept. The schema properties are generic (ref, url, city, feed, host, json, path) and do not clarify which one receives the key. The description adds no useful parameter mapping and introduces confusion.

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 ('Jira issue key shape'), so the core purpose is clear. It distinguishes itself from sibling shape checkers by naming Jira, but does not explicitly contrast with alternatives, and the schema has no property literally named as a Jira key, creating some ambiguity.

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

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

There is no when-to-use guidance, no mention of alternatives, and no prerequisites. The only additional sentence, 'Key discarded,' is a behavioral note, not a usage guideline. An agent cannot determine when to choose this over domain-shape, github-repo-shape, or validate-json.

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?

'Body discarded' is a genuine behavioral disclosure—it tells the caller the response will contain only the HTTP status. However, with no annotations provided, the description carries the full burden, and it fails to disclose that most of the 9 parameters are themselves discarded after shape/length checks, what happens when multiple parameters are supplied, or any authentication/rate-limit 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 two-sentence description is front-loaded and wastes few words. However, the brevity crosses from efficient into under-specified territory—critical details about output shape, parameter relationships, and scope are absent, so the description reads more like an abbreviation than a well-structured definition.

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

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

For a tool with 9 optional parameters, no output schema, and no annotations, a 12-word description is inadequate for correct invocation. An agent cannot determine which parameter drives the 'HTTP status' response, what the returned status is based on when inputs are discarded, or whether the tool validates a URL or merely echoes a checklist result.

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

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

Schema description coverage is 100%, with each of the 9 parameters already documented with a type and a usage note (e.g., 'discarded after the shape check'). Per the rubric, high schema coverage sets the baseline at 3, and the description does not need to compensate. The description itself maps to no specific parameter, but that is acceptable given the schema's completeness.

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 verb and resource ('HTTP status for a public library docs URL') and adds a distinctive behavioral note about discarding the body. However, it is vague about what 'public library docs' means, and it does not differentiate the tool from overlapping siblings like fetch-status, web-fetch, or browser-url-ok, which also deal with URL status. The 9-parameter schema (city, json, timezone, query) suggests a broader scope than the description implies.

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

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

No guidance is provided on when to use this tool versus alternatives. The sibling list contains highly overlapping tools (fetch-status, normalize-url, validate-json, web-fetch), and the description gives no selection criteria, no exclusions, and no conditions under which this tool should be preferred.

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

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

With no annotations provided, the description must carry the behavioral transparency burden. It does disclose that values are discarded, which is useful, but it does not explain behavior for invalid JSON, nested objects, empty objects, or the exact return value. This is a significant gap for a no-annotation tool.

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

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

The description is very short and front-loaded: 'Count keys in a JSON object' immediately conveys the core purpose, and 'Values discarded' adds a meaningful behavioral signal. There is no fluff, though it could be slightly expanded with key usage information without becoming verbose.

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

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

The tool has no annotations, no output schema, and nine parameters, so the description needs to compensate. It does not explain which parameter holds the JSON object, whether the count includes nested keys, or what the output shape looks like. This 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 description coverage is 100%, so the baseline is 3; each parameter already has its own description. However, the tool description does not identify which of the nine parameters contains the JSON object whose keys are to be counted, leaving some selection burden on the agent despite 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 states a specific action ('Count keys') and target resource ('in a JSON object'), and the note 'Values discarded' distinguishes it from a validation tool like validate-json. However, it does not clarify whether counting is top-level only or nested, leaving some ambiguity.

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

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

No guidance is given on when to use this tool versus siblings such as validate-json or other shape-check tools. The description implies it is for counting keys, but it does not state 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?

With no annotations provided, the description carries the full behavioral burden. It does disclose a meaningful behavior—'Query and fragment are dropped'—but it does not explain normalization details, error behavior, or the fact that many schema parameters appear to be intentionally discarded.

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

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

Two short sentences with no wasted words; the core behavior is front-loaded. The concise structure makes the tool 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?

For a tool with 9 parameters, no output schema, and no annotations, the description is too thin to be fully actionable. It does not explain why so many unrelated parameters exist, what the output structre looks like, or what 'normalize' entails beyond dropping query and fragment.

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 structured schema already documents every parameter. The description adds a little value by clarifying that the URL's query and fragment are dropped, but it does not meaningfully explain the role of the many other parameters or how they relate to the URL normalization task.

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

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

The description clearly states the tool's action ('Return origin, host, and path for a URL') and specifies a scope ('Query and fragment are dropped'). It gives a specific verb and resource, so an agent can understand the core function, but it does not explicitly distinguish it from URL-related sibling tools like browser-url-ok or domain-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 such as browser-url-ok, domain-shape, or web-fetch. The description does not state prerequisites, exclusions, or conditions that would help an agent select it over 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 behavioral burden. 'No browser is launched' is a meaningful behavioral disclosure and prevents an agent from expecting a browser session. However, it does not state whether a network request is made, whether inputs are retained, or what result is returned.

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, no filler, and the key behavioral qualifier follows immediately after the purpose. Every word earns its place.

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

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

The tool has nine optional parameters, no annotations, and no output schema, yet the description only covers the URL-checking case. It does not explain the remaining parameters, the return value, or when the tool should be preferred over sibling tools, so an agent would be under-informed for complex invocations.

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 at most a general sense that 'url' is the value being checked, but it provides no additional meaning for the eight other optional parameters and does not clarify their relation to 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 uses a specific verb and resource: 'Check whether a URL can be opened.' It is clear at a glance, and 'No browser is launched' adds a useful qualifier. However, it does not distinguish this tool from similarly named siblings like browser-url-ok, and the wide input schema suggests the tool may do more than the one-line purpose states.

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 mention of alternatives such as browser-url-ok, fetch-status, or web-fetch. The only hint is 'No browser is launched,' which implies a lightweight check but does not tell the agent which sibling to choose.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does state that the query is discarded, which is a genuine non-obvious behavioral trait, but it hides the broader behavior: the tool accepts nine heterogeneous parameters and ignores nearly all of them. It also does not disclose what it returns (a count? a boolean shape check?) or how it behaves on empty input, and no output schema exists to fill that gap.

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

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

Two short sentences with zero filler; the action is front-loaded and the discard warning earns its place. It is efficiently minimal, though the brevity crosses into under-specification given the tool's confusing schema.

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

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

The tool has 9 parameters, no annotations, and no output schema, yet the description is only eight words. It does not explain the return value, the purpose of the extra parameters, when to use the tool, or what happens if the query is empty. For a tool this structurally complex, the description is far from sufficient for correct selection and invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds one useful signal: among the nine parameters, 'query' is the one relevant to the tool's stated purpose. However, it adds nothing about how the other eight parameters relate to the tool, leaving their presence unexplained and potentially misleading.

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 characters in a search query'), so the core action is identifiable. However, it does not distinguish this from sibling counting tools like memory-key-count or hn-front-count, and it fails to reconcile the stated purpose with a 9-parameter schema full of unrelated inputs (city, timezone, feed, JSON, file path). An agent would be genuinely uncertain whether this tool relates to search, weather, or URL checking.

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 mention of the 8 evidently irrelevant parameters. The only implied context is 'you need a character count of a search query,' which is thin. Nothing tells the agent why it would ever pass a city, timezone, or file path to a character-counting tool.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure, but it offers only 'Short catalog ...', which implies read-only behavior without stating it. It also fails to disclose that most inputs (ref, url, city, feed, json, path) are seemingly only validated or discarded, as the input schema's field descriptions suggest.

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 terse and contains no filler, but it is under-specified for a tool with seven heterogeneous parameters. This is closer to under-specification than to effective concision, since no structure is used to clarify purpose or usage.

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 that the tool has no annotations, no output schema, and a schema spanning seven unrelated inputs, a one-line catalog description is incomplete. It does not explain why inputs like city, feed, or json are relevant, so an agent lacks enough context to invoke the tool 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?

All seven parameters have individual schema descriptions, so the description need not repeat parameter details. The description adds no meaning about how these heterogeneous inputs relate to an HTTP-status-code catalog, leaving that relationship unexplained, but the schema already covers each field's literal 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 identifies the resource ('common HTTP status codes') and indicates it is a reference catalog, so an agent can infer a lookup purpose. However, it lacks a specific verb and does not distinguish status-catalog from sibling tools like fetch-status, leaving ambiguity about whether this returns code meanings or fetches a live status.

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

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

No when-to-use guidance is given. The description does not mention any conditions, exclusions, or alternatives such as fetch-status or web-fetch, so an agent must infer from the name alone when this tool is preferred.

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. 'Prompt discarded' plus the per-parameter 'discarded' notes disclose a key trait: the tool ignores user input and does not process the prompt. This is meaningful behavioral transparency, though it does not describe the exact template content or explicitly rule out all 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 two short sentences with no filler, and the primary function is front-loaded. 'Prompt discarded' earns its place as a behavioral caveat.

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 that simply returns a fixed template, this is minimally adequate: the agent knows the output type and that the prompt is ignored. But it lacks context about when this tool is useful, what the three steps are, and how it fits among the many sibling tools, leaving some ambiguity.

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

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

Schema coverage is 100%, so the schema already documents all nine optional parameters. The description adds no parameter-level semantics beyond implying they are irrelevant, so the baseline of 3 is appropriate.

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

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

The description states a clear action and object: 'Return a three-step thinking template.' It is not a tautology and communicates the tool's basic function. However, it does not explicitly differentiate it from sibling tools or explain what the template contains.

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 any of the many sibling utilities. 'Prompt discarded' hints that the input content is ignored, but the description never states the intended invocation context or signals when an agent should choose think-steps over another tool.

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

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

No annotations are provided, so the description carries the full transparency burden. It communicates the read-only nature implicitly at best and says nothing about DST handling, validation of IANA names, error behavior, or output format.

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

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

The description is one short, front-loaded sentence with no wasted words. It is under-specified, but the conciseness and structure itself are good.

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 missing parameter and return-value info leaves the definition incomplete. An agent cannot know what to pass or what the tool will return, and the schema/description mismatch makes it worse.

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 parameters (ref, url, city, feed, host, json, path) appear unrelated to a timezone lookup, and there is no documented timezone or timezone-name field. The description's reference to a 'named IANA timezone' is not mapped to any actual parameter, so an agent cannot reliably construct a valid call.

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: return the current time for a named IANA timezone. It also helps distinguish the tool from the sibling utc-time by anchoring on named IANA zones. It loses one point because the input schema exposes no parameter that clearly represents the IANA timezone, creating 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?

There is no explicit guidance on when to use this tool versus utc-time or iana-zones. The intended context is only implied by the name and one-line description, so an agent gets no help choosing among the closely 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?

No annotations are present, so the description carries the burden of behavioral disclosure. It only names the output value and does not mention the return format, whether the tool makes a network call, whether parameters are honored, or any side effects. This is very thin behavioral coverage.

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 is appropriately front-loaded. It is terse, but not so under-specified that the sentence itself is wasteful.

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

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

Given a seven-property input schema and no output schema, a one-sentence description is insufficient. It does not explain the return type, the role of the optional parameters, or how this tool relates to the time-related siblings, leaving an agent without enough context for confident invocation.

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

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

The description adds no parameter meaning, but the input schema already provides descriptions for all seven optional properties, so the baseline is met. However, those descriptions concern shape checks, URL normalization, weather hints, and similar concerns, not UTC timestamp generation, so the description does not clarify why they appear on 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 that the tool returns the current UTC timestamp, which is a clear and specific purpose. It does not use a verb and closely mirrors the tool name, but it is precise enough to communicate what the tool produces.

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

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

There is no guidance about when to use this tool versus siblings such as timezone or iana-zones. No exclusions, alternatives, or context for selection are provided, leaving the decision 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?

Annotations already declare readOnlyHint and idempotencyHint, so the safety profile is covered. The description adds the useful no-retention detail that the body is discarded, but it does not address what happens for invalid JSON or which inputs are ignored; the boolean output is supplied by the output schema.

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

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

The description is two short sentences with the core action front-loaded and no filler. Each sentence earns its place: one for purpose, one for data-handling behavior.

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 annotations covering side effects and output_schema covering return type, the description is nearly complete for a simple validation tool. The main gap is the absence of an explicit pointer to the json parameter among the seven schema properties, but the schema description for json fills that 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?

All seven schema parameters have individual descriptions, so schema coverage is effectively 100% and the baseline is 3. The description's generic 'body' does not map explicitly to the json parameter or clarify the unused parameters, but the schema already describes json as the text to validate.

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

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

The first sentence, 'Check whether a body is valid JSON,' states the action, object, and validation criterion precisely. It is not a tautology and is easy for an agent to act on, though it does not explicitly differentiate from sibling validators/shape tools.

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

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

There is no guidance about when to choose validate-json over sibling tools, no explicit conditions, and no 'when not to use' note. The only additional sentence, 'The body is discarded,' describes a behavior rather than usage.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read-only external weather lookup, but it does not mention units, failure modes, rate limits, or the fact that all schema parameters except city are discarded.

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

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

The description is a single sentence with no filler and leads with the main purpose. It is concise, though slightly under-specified in operational detail.

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

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

Given no output schema, no annotations, and a 9-parameter schema full of apparently unrelated optional fields, a one-sentence description is inadequate. It does not explain the return payload, units, or how the unrelated parameters should be ignored.

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 already marks most parameters as discarded, so the baseline is 3. The description does add that 'city' is the operative parameter for temperature, but it does not help an agent understand how to treat the many unrelated optional parameters.

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

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

The description states that the tool provides current temperature for a city and names the data source (Open-Meteo). This is clear enough to identify the resource, though it lacks an explicit verb like 'gets' or 'returns' and does not explicitly contrast it with sibling hint tools.

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

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

No guidance is given about when to use this tool versus its many siblings. There are no exclusions, alternative tool references, or contextual hints beyond the fact that it is weather-related, which is insufficient for agent routing.

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 does add useful behavioral information by stating that the body is discarded and only status/content type are returned, which prevents agents from expecting page content. However, it omits other relevant behaviors such as redirect handling, timeout behavior, failure modes, and whether JavaScript rendering is performed.

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

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

The description is very short and front-loaded, with no filler or redundant wording. Every phrase earns its place, but it is somewhat undersized for a tool with nine optional parameters and many sibling tools.

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

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

Given the tool has no output schema, no annotations, nine optional parameters, and a large set of related siblings, the description is not complete enough. It explains one narrow use case but fails to inform the agent about the other parameters, the expected return shape, or how web-fetch relates to sibling tools.

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

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

The input schema covers all parameters individually with descriptions, but the tool description only mentions URL and does not clarify the role of the other eight optional parameters (ref, city, feed, host, json, path, zone, query). This mismatch is confusing: the description implies a simple URL-only tool while the schema accepts many unrelated inputs.

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

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

The description clearly states that the tool returns HTTP status and content type for a public URL, and 'Body discarded' signals a distinct scope. It lacks an explicit verb and does not differentiate itself from siblings like fetch-status or browser-url-ok, but the core purpose is still 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?

The only usage constraint is 'public URL', with no guidance about when to prefer this tool over the many related siblings such as fetch-status, browser-url-ok, normalize-url, or playwright-url-ok. There are no decision rules, exclusions, or alternative tool mentions 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?

No annotations are provided, so the description must carry the behavior burden. It discloses that the title is discarded after the call, which is a useful privacy/side-effect detail, but it does not describe the result format, network behavior, or what 'exists' means. This leaves most behavioral expectations unspecified.

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 and the key purpose is front-loaded; there is no filler. It is concise, though the brevity contributes to the parameter and context gaps that lower other scores.

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 seven-property input schema that does not visibly contain the stated 'title' input, this description is far from complete. An agent cannot reliably select, parameterize, or interpret the result of this tool 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 description mentions a 'Wikipedia title,' but the input schema has seven parameters (ref, url, city, feed, host, json, path), none of which are named 'title' or said to contain the title. The description adds no mapping between the title concept and any schema parameter, so an agent cannot determine what to pass.

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

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

The description states a specific verb and resource: 'Check whether a Wikipedia title exists.' This is clear and distinguishable as an existence check, though it does not name any sibling tool or explain how it differs from the many other shape/check tools, so it misses the top 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?

There is no guidance on when to choose this tool over alternatives such as normalize-url, validate-json, or other shape checks. The description gives only the core action, with no when-to-use or when-not-to-use context.

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