Australia/Hobart clock

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

Annotations already declare readOnlyHint=true, so the bar is lower; the description adds useful context beyond that by disclosing that task text is discarded, that the call involves remote MCP hops, and by enumerating the returned artifacts. This is consistent with the read-only annotation.

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

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

Three short sentences, each earning its place: the purpose, the returns, and the task-text discard warning. The main purpose is fixed-loaded first with zero 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 lists the four return artifacts, which partly compense for the absent output schema, and the schema documents each parameter. However, it never states which parameter actually drives the lookup, leaving the agent to infer that most inputs are merely shape checks - a real gap for a 6-parameter tool.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters (e.g., 'Git ref name; discarded after the shape check'). The description adds no parameter-level meaning, which matches the baseline of 3 where the schema carries the heavy lifting.

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 ('Find') and a distinct resource ('public pay-per-call tool gateway (Monid)') and lists what it returns (CLI setup, how-it-works, skill fil, and remote MCP hops). It is clearly distinguishable from the sibling utility-check tools, though it never explicitly contrasts itself with a sibling.

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

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

The description implies when to use it (whenever the agent needs Midid gateway setup or hop info) and provides an implicit exclusion via 'Task text discarded'. However, no alternative tool is named, and there is no explicit when-not-to-use 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 present, the description carries the full burden of behavioral disclosure. It discloses that no browser is launched, which is useful, but it fails to explain what 'can be opened' means operationally (e.g., HTTP response, DNS resolution, port reachability) or what side effects or return values to expect. The schema hints at unrelated behaviors like normalizing, citing, and discarding other inputs, which are not addressed in the description.

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

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

The description is two short sentences with no filler, and both sentences convey useful information: the core action and a key behavioral caveat. It is appropriately concise for the limited scope stated, though it lacks some depth that might be expected given the schema's complexity.

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

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

The tool has a rich schema with seven heterogeneous parameters, yet the description covers only the URL aspect and does not mention what the other parameters are for or that they are discarded. There is no output schema, and the description does not explain return values, error semantics, or how to interpret 'can be opened.' This leaves the tool incompletely specified 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?

The input schema provides descriptive text for all seven parameters, so schema coverage is high and the baseline is 3. The description adds no parameter-level guidance and does not clarify why parameters such as ref, city, feed, or json are present or how they relate to the stated URL-checking purpose. An agent cannot tell which parameter is the primary one, though 'url' is obvious from context.

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 URL can be opened.' This is clear and implies a lightweight validation task. The added clause 'No browser is launched' hints at a difference from browser-launching sibling tools, but no sibling is named, so differentiation is only implicit.

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 a usage context: use this when you need to know if a URL is openable without launching a browser. However, it does not explicitly say when to prefer this tool over alternatives such as playwright-url-ok or fetch-status, nor does it mention any exclusions or prerequisites.

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 explaining side effects and behavior. It adds only 'Expression discarded', which weakly implies persistence is not an issue, but says nothing about return values, errors, network use, permissions, or whether this is safe to call.

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 no filler; the operation is front-loaded and the 'discarded' caveat is a compact behavioral note. It is concise, though the brevity comes at the cost of 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?

There is no output schema and no annotations, and the description omits the input mapping and return contract. Given seven unrelated schema fields and no expression parameter, an agent cannot invoke this tool correctly based on the description alone.

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

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

The description mentions an arithmetic expression, but the input schema contains no expression, a, or b parameter — only ref, url, city, feed, host, json, and path. None of those fields maps to the a+b expression the description says it evaluates, and the description provides no guidance on where to place the expression. The schema descriptions do not rescue this because they describe entirely different payloads.

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 ('Evaluate a+b style arithmetic'), and no sibling tool obviously covers arithmetic, so some differentiation exists. However, 'Expression discarded' is ambiguous — it could mean the expression is only shape-checked and not computed — and the description never states what the tool returns. An agent cannot be confident whether this produces a numeric result or only validates 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?

There is no guidance about when to use this tool instead of a sibling, nor any condition or exclusion. The only implied context is arithmetic evaluation, but nothing explicit helps an agent route to it correctly.

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

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

With no annotations supplied, the description carries the burden of behavioral disclosure. 'Page content is not stored' is a useful behavioral guarantee, but the description omits other relevant traits such as side effects, permissions, or how the extra input parameters are treated beyond what the schema already says.

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

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

The description is extremely concise, front-loaded with the core behavior, and every sentence earns its place. The non-storage sentence adds meaningful behavioral context 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?

For a tool with seven varied parameters and no output schema, the description is thin. It tells the agent what is returned, but not which inputs are required or how the unrelated-looking parameters (ref, city, feed, json, path) relate to the citation behavior. The schema helps, but the description alone leaves too much to inference.

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

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

All seven parameters already have descriptions in the input schema, so the schema coverage is high and the baseline is 3. The tool description mentions 'a URL' but adds no parameter-level meaning beyond that; it does not clarify the relationship between url, host, json, and the other 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 verb and output ('Return host, scheme, and HTTP status for a URL') and adds a clarifying non-storage guarantee. It does not explicitly distinguish itself from siblings like fetch-status or normalize-url, so it falls short of a 5.

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

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

No guidance is given about when to use this tool versus alternatives such as fetch-status, normalize-url, or web-fetch. The non-storage note implies a privacy-conscious use case, but there is no explicit when-to-use or when-not-to-use direction.

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 more burden; it does add one useful behavioral fact ('No identifiers are retained') and implies a read-only operation. However, it does not disclose whether any external data is accessed, how 'classification' is computed, or what the response looks like, 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 two sentences are front-loaded and free of fluff, and the privacy sentence earns its place. But the description is under-sized for a tool that accepts 9 heterogeneous optional parameters, so it reads more like a stub than a deliberately concise spec.

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 9 varied optional parameters, an agent cannot tell what inputs would be meaningful, what classification result to expect, or how to interpret success/failure. The description is not complete enough to support 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?

Schema description coverage is 100%, so parameter semantics are already documented in the input schema. The tool description itself contributes no additional parameter meaning beyond the privacy notice.

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 a general object ('show how this request is classified') but never defines what classification is being produced, what categories or dimensions are used, or how this relates to the tool name 'compatibility'. It is vague enough that an agent cannot reliably distinguish 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 about when to use this tool versus any of the 27 siblings, such as normalize-url, validate-json, iana-zones, or weather-hint. No exclusions, prerequisites, or alternatives are mentioned.

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

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

No annotations are present, so the description carries the full burden. It discloses that the tool does not provide WHOIS or ownership data, which is useful. However, it does not describe the output format, whether it validates hostname syntax, or how invalid inputs are handled. The behavior is only partially transparent.

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

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

The description is a single 11-word sentence with no fluff. The verb and object are front-loaded, and every word earns its place. The negative qualifier 'without WHOIS or ownership data' adds important distinction without unnecessary length.

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

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

The tool is simple, but the description is inadequate relative to the complex schema. It does not specify which input parameter should be used, what the return value looks like, or how to handle the many unrelated schema fields. There is no output schema, and the mismatch between the description (hostname-focused) and the schema (many input types) leaves the agent uncertain about correct invocation.

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

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

The input schema contains seven properties with individual descriptions, including 'host' described as 'Public hostname', which aligns with the tool's purpose. Schema coverage is high (100%), so the baseline is 3. The description does not map the 'hostname' concept to the 'host' parameter, nor does it clarify why unrelated parameters (e.g., 'city', 'json') appear in the schema. No added 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 'Split a hostname into labels without WHOIS or ownership data' clearly states a specific verb ('split') and resource ('hostname'), and explicitly distinguishes itself from WHOIS/ownership lookup tools. The purpose is unambiguous and aligns with the tool name, setting it apart from siblings like 'figma-url-shape' or 'github-repo-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 usage: when a hostname needs to be split into labels. However, it does not explicitly mention alternatives, when not to use the tool, or compare to closely related siblings like 'normalize-url' or 'web-fetch'. No exclusions or conditions are provided, so usage guidance is only implicit.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states that it performs a HEAD request and returns only status, which hints at non-destructive behavior. However, it does not disclose any side effects, authentication needs, rate limits, or what happens with non-URL parameters. The disclosure is minimal and leaves much to inference.

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

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

The description is extremely concise, a single sentence, and front-loaded with the core action. However, it is under-specified for a tool with 9 optional parameters and no output schema. It is not verbose but lacks structure and depth, so a 3 is fair.

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 is only one vague sentence about HEADing a URL. It does not explain how the other parameters are used (though the schema does mention they are discarded), what 'status' means, or how the tool behaves with different inputs. It is severely incomplete for the tool's complexity.

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

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

Schema description coverage is 100%, so the schema fully documents all 9 parameters, including that many are discarded. The description adds no parameter-level meaning beyond the schema. It mentions 'public URL' but does not map this to the 'url' parameter explicitly. Baseline 3 is appropriate since the schema handles 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 verb and resource: 'HEAD a public URL and return status only.' It is clear and distinguishes from siblings like normalize-url or web-fetch, but it does not explicitly differentiate from browser-url-ok or playwright-url-ok, which also check URLs. A 4 is appropriate because it is clear but lacks explicit sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any conditions, exclusions, or reference to sibling tools. There is no context about use cases, prerequisites, or when to prefer it over other URL-checking tools.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It only discloses one behavior, 'Path discarded,' and says nothing about side effects, network access, output format, error behavior, or required permissions. This is insufficient for an unannotated tool, though the single disclosed behavior prevents a score of 1.

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

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

Two short sentences with no filler: the core action is front-loaded and the caveat follows. It is concise, though 'Path discarded' is a fragment that could have been integrated into a more structured single sentence.

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

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

With nine optional parameters, no annotations, and no output schema, the description must explain what the parse produces and how the tool behaves. It does not describe return values, which inputs matter, or whether any network access occurs. This leaves a substantial completeness gap for an agent deciding whether to invoke the tool.

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

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

The input schema has 100% parameter description coverage, so the baseline is 3. The description does not meaningfully add parameter-level detail; 'Figma file URL' maps loosely to the existing `url` parameter, and 'Path discarded' is ambiguous between the URL path and the `path` input parameter. It does not clarify which of the nine parameters are actually relevant.

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: 'Parse a Figma file URL.' This distinguishes it from siblings like github-repo-shape, domain-shape, and normalize-url by restricting it to Figma file URLs. The added behavioral note 'Path discarded' provides extra differentiation without restating the tool name.

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

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

The description implies the tool should be used when an agent needs to parse a Figma file URL, but it does not explicitly state when not to use it or compare it with alternatives such as normalize-url, browser-url-ok, or web-fetch. The usage context is present only by implication.

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 explaining behavior. It does disclose 'No disk access,' which is useful, but it does not mention return values, error behavior, side effects, or whether the check is syntactic, semantic, or security-related.

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 direct, but it is too sparse to be considered well structured. It provides no output details, no examples, and no organization of the many parameters, so the brevity comes at the cost of 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 the tool has nine optional parameters and no output schema, the description is severely incomplete. It does not explain what constitutes a 'safe' path, which parameters are relevant, how the unrelated parameters are handled, or what the caller should expect in response.

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

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

Although the schema has 100% description coverage, most parameter descriptions are irrelevant to a file-path check. The 'path' field is described appropriately, but the presence of eight unrelated optional parameters with no explanation of how they relate to the tool makes the parameter semantics confusing and inconsistent.

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: 'Check whether a path looks safe.' However, it does not define what 'safe' means, and the parameter list includes many unrelated fields (ref, url, city, feed, host, json, zone, query), which muddies the tool's actual purpose.

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

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

No guidance is provided about when to use this tool versus alternatives such as browser-url-ok, normalize-url, or validate-json. The description merely repeats the tool name and gives no conditions, prerequisites, or 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?

There are no annotations, so the description must carry the burden of behavioral disclosure. 'Via Open-Meteo' hints at an external network lookup, but the description does not state whether the call is read-only, what errors may occur, whether there are rate limits, or what the response shape is.

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 sentence with no filler; the core function and provider are front-loaded. It is as concise as a tool summary should be.

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

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

Despite a rich seven-field schema and no output schema, the description does not explain which parameters are required or which one supplies the place. It leaves the agent to infer that 'city' is the relevant input and omits any mention of output format or constraints.

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

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

The input schema already provides descriptions for all seven parameters (ref, url, city, feed, host, json, path), so schema coverage is high. The tool description adds no parameter-level meaning and does not clarify which parameter is the intended 'place', but the schema's city description is sufficient for a baseline.

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

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

The description clearly identifies the tool as a latitude/longitude lookup ('Latitude and longitude for a place') and names the provider (Open-Meteo). It implies a geocoding operation and helps set it apart from sibling tools like weather-hint, though it lacks an explicit verb such as 'Returns'.

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

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

No guidance is given about when to use geo-hint versus alternative tools. It does not mention that coordinates are needed for weather-hint or timezone, nor does it name any sibling or exclusion conditions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the core parse behavior but does not mention validation strictness, output format, normalization, or that most other input parameters are discarded after the shape check. It is not misleading but is under-specified for edge cases.

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 sentence with no filler, front-loading the core action and target resource. It is appropriately concise for a simple parse tool, though a small amount of additional context about output or validation would be acceptable.

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 10 parameters and no output schema, yet the description only covers URL-to-owner/repo parsing. It omits the 'shape check' behavior implied by the name, the discarding of extra parameters, and any output or failure semantics. An agent would not be fully equipped to call it correctly beyond the simplest case.

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 10 parameters have schema descriptions, so the baseline is 3. The tool description adds meaning by identifying 'url' as the GitHub URL and owner/repo as the extracted output, but it does not clarify the discard behavior of the many other parameters beyond what the schema already states.

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

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

The description states a specific verb ('Parse') and resource ('owner and repo from a GitHub URL'), making the tool's primary function clear. It distinguishes itself from sibling shape tools by scoping to GitHub URLs, though it does not explicitly contrast with them.

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

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

The GitHub URL qualifier implies this tool is for GitHub repo URLs, which gives some usage context. However, there is no explicit guidance on when to choose this over sibling shape tools like figma-url-shape or jira-key-shape, nor any 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 (readOnlyHint/destructureHint) are provided, so the description bears the full burden of behavioral disclosure. 'Titles discarded.' hints at an output trait, but its referent is ambiguous: are HN story titles dropped from results, or are the 7 unrelated inputs (ref, city, json, path) all discarded? It doesn't disclose that this is a read-only count or that most parameters are ignored, and it says nothing about auth, rate limits, or side effects. No annotation contradiction exists because no annotations were 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?

The text is admirably efficient: two short sentences with the verb front-loaded in the first. Every word earns its place. It falls just short of 5 because 'Titles discarded.' is cryptically terse and its meaning is ambiguous without supporting context.

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 7 parameters, no output schema, and no annotations, the description had to explain inputs and outputs — it explains neither. An agent cannot infer which parameter yields the count or what the result looks like. The gap between the stated purpose and the schema is severe: 'city', 'host', 'json', and 'path' are entirely unrelated to Hacker News front-page story counting, and the description does nothing to reconcile this.

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 7 parameters individually (e.g., 'Git ref name; discarded after the shape check'), so the schema mostly does the heavy lifting — the baseline would be 3. But the description adds no parameter guidance and never connects its stated purpose ('Count current Hacker News front-page stories') to any of ref, url, city, feed, host, json, or path. The only overlap, 'Titles discarded.', merely echoes the feed parameter's description without clarifying which inputs are actually used.

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.' This is genuinely informative about what the tool does. However, it does not explicitly differentiate from sibling tools such as web-fetch or fetch-status, and the second sentence 'Titles discarded.' is ambiguous, so it falls short of a 5.

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

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

No when-to-use guidance, no exclusion criteria, and no alternative tools are named. An agent reading the description cannot determine when to pick this tool over web-fetch or fetch-status, nor whether it should supply a URL, feed, or JSON input to obtain the count.

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 — and it discloses nothing. It does not mention that the tool appears to perform shape/validity checks, that parameter values are discarded, whether the operation is read-only, or what the response looks like. The schema hints at discard/validation behavior, but the description itself is completely silent.

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

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

The description is a single short sentence with no wasted words and is reasonably front-loaded. However, the brevity is achieved by omitting the verb and any operational detail, which edges toward under-specification rather than disciplined conciseness. It reads cleanly but sacrifices substance for compactness.

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 9-parameter tool with no annotations and no output schema, so the description carries the full burden — and it is grossly inadequate. It fails to explain the tool's operation, its relationship to siblings like timezone, what inputs it accepts beyond the domain hint, or what the caller should expect in return. An agent cannot reliably invoke or interpret this tool from the description alone.

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

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

The schema already provides descriptions for the parameters (e.g., 'Git ref name; discarded after the shape check', 'HTTPS URL to normalize or cite'), giving good coverage. The tool description adds only the IANA timezone domain context, which helps interpret the timezone parameter but does not compensate for anything missing. With schema coverage this high, 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 (IANA timezone names) and a context ('for clock calls'), but contains no verb — it never states what operation the tool performs (list? validate? look up? return?). An agent reading 'Common IANA timezone names for clock calls' cannot tell whether this tool returns names, validates them, or something else. It is a noun phrase closer to a tautology than a functional statement.

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

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

The phrase 'for clock calls' implies the tool is meant to supply timezone names to clock/timezone operations, which weakly distinguishes it from siblings like timezone or utc-time. However, it never explicitly states when to use this tool versus the timezone sibling, nor names any alternative or exclusion. The usage context is implied 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?

With no annotations, the description carries the burden, and 'return group counts only' does disclose a narrowed, read-only behavior. However, it omits which of the eight parameters are actually used, how a missing robots.txt is handled, and what 'groups' means. These are material behavioral gaps.

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 sentence with no filler; the key action and result 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?

Given an 8-parameter schema, no annotations, and no output schema, this one-liner is insufficient. An agent cannot reliably tell which parameter to populate (likely 'host') or what the counted groups look like, so successful invocation depends on guessing.

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

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

The input schema describes all 8 parameters, so the baseline is 3. The description adds no parameter-specific meaning; it doesn't map 'robots.txt' to the 'host' or 'url' fields, nor does it clarify that most parameters are discarded.

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

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

The description states a specific verb ('Fetch'), a concrete resource ('a public robots.txt'), and a clear output ('return group counts only'). This distinguishes it from generic siblings like web-fetch or fetch-status by the robots.txt 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?

Intended use is implied ()when robots.txt group counts are needed), but the description gives no explicit when-to-use/when-not-to-use guidance and does not mention alternatives. An agent must infer the selection from the resource name.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It only states 'Key discarded,' which hints that the input is not retained, but does not explain return values, side effects, or what happens to the other schema properties. The relationship between the stated 'key' and the seven unrelated parameters is unexplained.

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

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

The description is short and front-loaded, with no wasted words. However, it is under-specified for a tool with seven parameters and no additional context, so the brevity crosses from concise into incomplete.

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 complex schema with seven heterogeneous properties, no annotations, and no output schema, the description is severely incomplete. It omits which parameter is the key, what the tool returns, and when it should be used. An agent would struggle to invoke this tool correctly based on the description and schema 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?

Although the schema covers 100% of parameters with descriptions, the descriptions are generic and unrelated to Jira key shape (e.g., 'city', 'json', 'feed'), and the tool description introduces a 'key' parameter that does not exist in the schema. This creates confusion rather than clarity, so the baseline of 3 is not met.

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 explicitly states the action ('Check') and the resource ('Jira issue key shape'), which is specific and distinguishes it from sibling shape-checkers like domain-shape or figma-url-shape. However, it does not clarify which of the seven input parameters represents the key, leaving a small but meaningful 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 for when to use this tool versus alternatives. There is no mention of context, prerequisites, or exclusion criteria, so an agent cannot determine if this is the right checker for a given input.

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

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

There are no annotations, so the description carries the full burden. It does disclose a key behavioral trait: 'Body discarded,' meaning the returned value is only an HTTP status. However, it does not mention whether the operation is read-only, how the extra schema parameters are treated, or any 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 waste. The main purpose is front-loaded, and the behavioral trait 'Body discarded' is stated separately. It is concise, though the brevity comes at the cost of necessary context.

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

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

With seven parameters, no annotations, and no output schema, the description is incomplete. It does not explain what a 'public library docs URL' is, how the various parameters interact, or when to prefer this over sibling status/shape tools. The mismatch between the single-purpose description and the heterogeneous schema is a significant 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?

The input schema gives a description for every parameter, so schema_description_coverage is high. The tool description adds no parameter-level meaning and does not clarify how parameters like `city` or `json` relate to the stated purpose. 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 specific purpose: returning HTTP status for a public library docs URL and discarding the body. However, the input schema lists seven heterogeneous parameters (ref, city, feed, json, path) that are unrelated to this stated purpose, creating ambiguity about what the tool actually accepts. It also does not differentiate from sibling tools like fetch-status or web-fetch.

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

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

The description provides no guidance on when to use this tool versus alternatives. It neither names sibling tools nor gives exclusions. The intended usage is only implied: use it when you need HTTP status for a public library docs 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 behavioral burden. It explicitly says values are discarded, which signals a pure read-only count and tells callers that value content can be ignored. However, it does not state the return format, malformed-input behavior, or whether key counting is recursive, so transparency is adequate but not complete.

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, action first, with no filler. 'Values discarded' carries meaningful behavioral information beyond the schema. It is appropriately concise, though the brevity leaves important invocation details uncovered.

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?

No output schema, no annotations, and nine optional parameters mean the description needs to provide more invocation guidance. It does not explain the return value, how to identify the JSON object among the parameters, or key-count scope. The definition provides the gist but not enough to ensure correct 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?

Although every parameter is documented in the schema, the description never maps 'JSON object' to a specific parameter such as `json`. The schema itself describes `json` as 'JSON text to validate', which conflicts with the count-keys purpose, and with nine optional parameters the caller cannot reliably know which argument 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 operation ('Count keys') on a specific resource ('a JSON object') and adds that values are discarded, which distinguishes it from siblings like validate-json. It does not specify nested vs top-level keys or how the object is supplied, 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?

There is no when-to-use or when-not-to-use guidance and no mention of alternatives, despite many sibling tools. The only usage signal is implied by the name and one-line description; no exclusions, prerequisites, or comparisons 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?

With no annotations, the description carries the behavioral burden. It discloses the key quirk that query and fragment are dropped, which is valuable. However, it does not address invalid URLs, output format, or the fact that only the 'url' parameter appears to be consumed, leaving the agent with some 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?

Two tight sentences with no filler, front-loading the primary behavior and the notable query/fragment dropping 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?

Given seven input parameters, no output schema, and no annotations, the description is too thin. It fails to clarify the input mode (url only) or the structure of the returned origin/host/path, leaving significant ambiguity in a schema-heavy 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?

While the schema gives each param a description (100% coverage), the tool description adds no clarity on which parameter is the actual input. The schema itself is confusing: 'host' and 'path' resemble outputs yet are listed as inputs, and several fields are marked discarded. The description should explicitly point to 'url' but does not.

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 ('Return') and names concrete outputs (origin, host, path) plus a clear transformation (query/fragment dropped). This unambiguously distinguishes it from sibling shape-check and URL-validation tools.

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

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

The description implies when to use the tool (when normalized URL components are needed) but provides no explicit when-not-to-use or alternative tools. It leaves routing entirely to inference.

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

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

Annotations already cover read-only, non-destructive, idempotent behavior. The description adds one meaningful behavioral fact, no browser launched, but does not clarify whether any network request is made or what 'opened' means. No contradiction with 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?

One short, front-loaded sentence containing exactly the core action and the critical no-browser qualifier. Every word contributes 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?

Despite schema descriptions and annotations, an agent still cannot tell what the return value will be, which parameter is primary, or how 'can be opened' is determined. With seven parameters and no output schema, the description should provide more 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?

All parameters are already described in the input schema, so the baseline is 3. The description adds no parameter-level guidance and does not explain why unrelated parameters like city, feed, json, or path exist for a URL 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?

States a specific action (check) and resource (URL), with a useful qualifier ('No browser is launched'). However, 'can be opened' is ambiguous between syntactic validation and actual reachability, and it does not explicitly differentiate from sibling tools like browser-url-ok.

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

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

No guidance is given for when to use this tool versus alternatives such as browser-url-ok, web-fetch, or normalize-url. There are no conditions, exclusions, or preferred scenarios described.

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 adds the behavioral note 'Query discarded,' indicating the input is not retained, and 'Count characters' implies a read-only operation. Since no annotations are present, this disclosure is valuable, though it does not address potential return format or other side effects.

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

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

The description is highly concise: two short sentences with no fluff. It front-loads the primary action and includes a useful side-effect note. It earns a 4 for efficiency, but the brevity contributes to the ambiguity noted.

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 schema has seven unrelated string parameters and no output schema, the description is incomplete. It neither indicates which parameter represents the search query nor states the return value (presumably the character count). An agent cannot confidently invoke this tool correctly based on the description alone.

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

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

Even though the schema's per-property descriptions are detailed (coverage is high), the tool description fails to map the 'search query' to any of the seven schema properties. This creates confusion about which parameter to pass, and the description adds no clarifying meaning 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 clearly states the action ('Count characters in a search query') and, by its subject, distinguishes itself from sibling count tools. However, the resource 'search query' does not correspond to any parameter in the input schema, which lists ref, url, city, feed, host, json, and path. This mismatch makes the purpose vague in practice.

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 any context, prerequisites, or exclusions, such as which parameter constitutes the search query or when this tool would be preferred over other count/shape-check tools.

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

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

With no annotations present, the description carries the full burden of disclosing behavior, but it only states that a catalog exists. It does not mention side effects, output shape, error behavior, or the fact that most inputs are 'discarded' after checks. The schema's param-level notes reveal some behavior, but the description itself adds no transparency.

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 brief but under-specified rather than efficiently informative. It has no wasted words, yet it also lacks any operational anchoring; for a tool with seven diverse parameters and no other context, this brevity is closer to incompleteness than to good concision.

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

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

The description is far too short for a tool with seven heterogeneous parameters, no output schema, and a large sibling set. It does not explain what the tool returns, which parameter should be supplied, how the catalog relates to the inputs, or when it should be preferred over a sibling. An agent cannot invoke this correctly based on the description alone.

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

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

The tool description itself says nothing about parameters, but the input schema provides descriptions for all seven properties, so schema coverage is high. Per the baseline rule, this earns a 3 because the schema carries the semantic weight, even though the description does not explain why parameters like city or feed relate to HTTP status codes.

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

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

The description 'Short catalog of common HTTP status codes' is a noun phrase, not a statement of what the tool does; there is no verb indicating an operation like 'look up' or 'return'. It roughly restates the tool name and gives no clue that the input schema contains unrelated params such as city, feed, or json, so an agent cannot infer the tool's actual behavior.

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

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

The description gives no guidance on when to use this tool versus alternatives like fetch-status, domain-shape, or validate-json. There are no conditions, exclusions, or examples of appropriate calls, leaving the agent to guess whether this is a lookup, a validator, or a source of hints.

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 discloses that the prompt is discarded, which is a meaningful behavioral trait. However, it does not mention that all parameters are discarded after shape checks (as indicated in the schema descriptions), nor does it explain the lack of side effects or output structure. Partial disclosure but incomplete.

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 that states the core function and a key behavioral note. No wasted words; every phrase earns its place.

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

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

For a tool with 9 parameters, no annotations, and no output schema, this description is severely under-specified. It does not explain what the three-step template contains, when it should be used, or how the parameters relate to the output. An agent would need to rely heavily on the schema and guess at the intended use case.

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 every parameter is documented with its purpose and discard behavior. The description adds no parameter-specific information, but the schema fully compensates. 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?

States a specific verb ('Return') and resource ('a three-step thinking template'), which is clear and distinct from sibling tools like shape checkers or validators. It does not explicitly differentiate from siblings, but the function is unique enough that confusion is unlikely.

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 on when to use this tool vs alternatives. The description gives no context for invocation, no exclusions, and no indication of what situations call for a thinking template. The 'Prompt discarded' note hints that it might be used when input is irrelevant, but that is not made 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It says the tool returns the 'current time,' implying a read-only operation, but it does not disclose whether network access is required, whether the time source is authoritative, or whether the value is inherently time-dependent. The description is too sparse to provide meaningful behavioral transparency.

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

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

The description is a single compact sentence and communicates the core function without wasted words. It is front-loaded and easy to read. The brevity is acceptable for a simple tool description, even though it omits essential parameter information.

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

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

With no annotations, no output schema, and an input schema that lacks any timezone-related parameter, the description is far too incomplete for an agent to select and call the tool correctly. The meaning of the description and the structure of the input schema are disjoint. This is a severe contextual 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?

The input schema contains seven parameters (ref, url, city, feed, host, json, path), none of which is a timezone identifier. The description refers to a 'named IANA timezone' but gives no indication of which schema parameter supplies that name. This is a critical mismatch between description and input schema, leaving the agent unable 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 states a specific verb and resource: it gives the current time for a named IANA timezone. This clearly distinguishes it from the utc-time sibling, which likely returns UTC time only. However, it does not mention the input parameter used to specify the timezone, which muddies the meaning slightly.

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 the agent needs the current time in a named IANA timezone. It does not explicitly contrast it with utc-time or iana-zones, nor does it state when not to use it. The usage context is present only by implication.

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 disclose behavioral traits. It only says 'Current UTC timestamp' and does not explain that the tool is read-only, that parameters are discarded or used only for shape checks, or that the output is unaffected by the parameters. This lack of disclosure could lead an agent to assume the parameters influence the result.

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

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

The description is a single sentence with no wasted words. It states the core purpose directly and front-loads the primary function. While it is minimal, it earns its place by clearly identifying what the tool does without verbosity.

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 there are 9 parameters, no output schema, and no annotations, the description is severely incomplete. An agent does not know that all parameters are optional and discarded, that the tool is read-only, or what the return format is. The tool's behavior and the role of its parameters are not explained, making it difficult to call 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?

The input schema has 100% description coverage, with each parameter described individually (e.g., 'discarded after the shape check'). The tool description itself adds no parameter semantics, but since the schema already documents them well, the baseline of 3 is appropriate. It does not compensate for the missing context about how parameters relate to the output.

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 UTC timestamp. It is specific and not a tautology, but it does not differentiate from sibling tools like 'timezone' or 'iana-zones' which may also return time-related data. It leaves the agent to infer which tool to pick based on the name alone.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention any exclusions, prerequisites, or mention of the 9 parameters and their role in validation. An agent cannot determine when this tool is the right choice over siblings like 'timezone' or 'calc-eval'.

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 behavioral burden. It usefully discloses that the body is discarded, which implies no persistence or side effects, but it does not state what is returned for valid versus invalid JSON, whether it throws, or how errors are surfaced.

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 operation is front-loaded, and the discard behavior earns its own sentence because it is a useful side-effect disclosure.

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

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

Given seven optional parameters, no annotations, and no output schema, the description is too thin. It never states the return format, never maps 'body' to the 'json' parameter, and never explains whether other parameters are ignored or relevant, leaving an agent under-equipped 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?

The schema provides descriptions for all seven properties, so schema coverage is high and the baseline is 3. The tool description adds no parameter-level meaning and does not clarify why non-json parameters like 'ref', 'city', or 'host' appear in a JSON validator, but the 'json' parameter itself is clearly documented in the schema.

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

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

The description names a specific action ('check') and a specific resource ('a body' / JSON), so the basic purpose is clear. It does not explicitly differentiate itself from sibling validation tools, but 'valid JSON' is unambiguous enough that an agent can tell this tool from URL/file/shape validators.

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

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

The description gives no guidance about when to prefer this tool over alternatives, what inputs are appropriate, or what conditions make it the right choice. No exclusions or sibling references are provided, so an agent must infer usage purely from the name and one-line action.

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. It only mentions 'via Open-Meteo', implying an external call, but does not disclose rate limits, caching, privacy, or that the city parameter is discarded. The schema notes 'discarded after the call', but the description itself offers no such detail.

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

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

The description is a single eight-word sentence with no filler. The subject is front-loaded, and every word contributes to conveying the tool's purpose. It is appropriately sized for its minimal scope.

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

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

The description lacks essential context for an agent to invoke the tool correctly. There is no output schema, no stated return value format (e.g., units), and no clarification of how to handle the extraneous schema parameters. For a tool with a confusing input schema and no annotations, this is insufficient.

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 includes seven parameters, but the description only references the city concept. Schema coverage is low (~14%), and the description does not clarify that only 'city' is relevant or that other parameters are ignored. The schema already documents 'city' well, but the description fails to compensate for the ambiguity introduced by the unrelated parameters.

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

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

The description states a clear resource (city) and data source (Open-Meteo), making the tool's core function understandable. However, it lacks an explicit verb (e.g., 'Gets') and does not differentiate from sibling tools, though no other weather-specific sibling exists.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention exclusions, preferred contexts, or relationships to siblings like geo-hint or lib-docs-hint. Usage context is only implied by the tool name and description.

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

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

The sentence 'Body discarded' is a useful behavioral disclosure that is not present in any annotation and tells the agent not to expect page content. However, it does not describe behavior for the non-URL parameters, multi-input selection, redirects, errors, or rate limits, especially important given there are no annotations to carry that burden.

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

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

The description is two short sentences with no filler. The primary return values are front-loaded, and the body-discard warning is an essential additional fact that 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 seven heterogeneous parameters and no annotations or output schema, this description is too thin. It does not specify which parameter is the actual fetch target, how content type is returned, or why the other parameters exist, leaving an agent uncertain about how to invoke 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?

The schema already provides descriptions for all seven parameters, so the baseline is 3. The tool description adds little parameter-level meaning beyond the 'public URL' qualifier, and it does not explain how city, json, ref, or path relate to the stated URL-fetching 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 concrete outcome: HTTP status and content type for a public URL. It is clear what the tool does, though it does not differentiate itself from the similar sibling fetch-status, and the seven heterogeneous input fields (city, json, path, ref) are not reconciled with the URL-focused framing.

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 web-fetch versus fetch-status, normalize-url, or browser-url-ok, and no exclusions are given. The phrase 'public URL' implies a usage constraint, but it is not enough to help an agent choose among sibling tools.

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

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

The description adds the useful behavioral detail that the title is 'discarded after the call,' implying no retention or side effects. However, with no annotations, it does not disclose the return value, error behavior, or whether existence is checked exactly or as a prefix.

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 are front-loaded with the primary purpose: 'Check whether a Wikipedia title exists.' The additional 'Title discarded after the call' is a relevant detail with no wasted words.

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 definition is not complete enough to call reliably: there is no output schema, no guidance on what the tool returns, and the schema has seven string parameters that appear unrelated to the described Wikipedia-title check. An agent cannot determine which parameter carries the title or what a successful check 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?

The description introduces a conceptual 'title' input, but the input schema contains no 'title' parameter or any parameter clearly representing a Wikipedia title. Instead it lists unrelated parameters like ref, url, city, feed, host, json, and path, making it impossible for an agent to map the intended argument to 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 verb and resource: 'Check whether a Wikipedia title exists.' This clearly distinguishes it from sibling URL, fetch, and validation tools by naming Wikipedia titles as the target. The purpose is unambiguous even though the schema does not match.

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 normalizing a URL, fetching a page, or validating other shapes. The description only says what the tool does, not when it should be preferred or avoided.

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