America/Buenos_Aires clock

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

No annotations are present, so the description carries the burden. It does disclose that task text is discarded and lists the returned artifacts, which provides some transparency. However, it does not mention potential side effects, authentication needs, network behavior, or cost implications despite the 'pay-per-call' context.

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

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

Two efficiently written sentences with the main purpose front-loaded. Each clause carries distinct information—resource, returned artifacts, and a behavioral note—with no redundancy or filler.

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

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

For a simple lookup tool with six schema-covered parameters and no output schema, the description adequately conveys the output categories and the fact that task text is ignored. It could be slightly more complete with output format or authorization hints, but it is largely sufficient for correct invocation.

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

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

The input schema provides descriptions for all six parameters (100% coverage), so the description adds no parameter-specific detail beyond what is already structured. The 'task text discarded' note is a general behavioral observation, not a parameter explanation. Baseline 3 applies.

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

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

The description uses a specific verb 'Find' with a clearly identified resource ('public pay-per-call tool gateway (Monid)') and enumerates what it returns (CLI setup, how-it-works, skill file, remote MCP hops). It is unambiguous about the tool's function but does not explicitly 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?

The phrase 'Find a public pay-per-call tool gateway' implies when to use it, but there is no explicit statement of when to choose this over alternatives, nor any exclusions or prerequisites. This is implied usage rather than direct 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?

There are no annotations, so the description must carry the behavioral burden. It does disclose one key behavior ('No browser is launched'), which is valuable. However, it is ambiguous whether 'can be opened' involves a network request or only a shape/syntax check, and it does not mention any side effects, permissions, or output characteristics.

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

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

Two short sentences, front-loaded with the core action and immediately clarifying the important side-effect negation. Every word earns its place; nothing is redundant.

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 check tool, and the schema supplies parameter-level context. But with no annotations and no output schema, the agent is left without information about what the tool returns or how the many parameters relate to the core 'URL can be opened' purpose. Some additional context about intended use would round it out.

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 seven parameters, each with meaningful detail (e.g., 'discarded after the shape check'). The overall tool description adds no parameter-specific meaning, but because schema coverage is effectively 100%, a baseline of 3 is appropriate and no compensation is required.

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

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

The description states a specific action (check whether a URL can be opened) and explicitly notes the absence of a browser launch, which helps distinguish it from a browser-automation tool. It is clear, but it does not explicitly name or contrast sibling checkers to differentiate them further.

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

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

No guidance is given about when to use this tool versus alternatives like domain-shape, playwright-url-ok, or normalize-url. The description only says what it does, not under which conditions an agent should choose it.

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

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

The only disclosed behavior is 'Expression discarded', which hints at a non-persistent operation. With no annotations provided, the description does not say what the tool returns, whether it is read-only, how errors are handled, or what side effects might occur.

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

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

The description is short and front-loaded with no filler words. However, its minimalism leaves out essential context about how the tool relates to its input schema, so the conciseness is not paired with sufficient substance.

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 severely incomplete. It does not explain what result is returned, which parameter is required for the arithmetic expression, or how the various schema fields 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?

The schema provides descriptions for all seven parameters, so schema coverage is high. The description does not add any mapping between 'a+b style arithmetic' and a schema field, and it fails to identify which parameter carries the expression, but it also does not contradict the schema.

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

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

The description names a specific operation: evaluate a+b style arithmetic. However, the input schema contains no expression parameter, and the description does not distinguish calc-eval from the many sibling shape/validation tools, so the intended purpose remains vague in context.

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 validate-json or domain-shape. The description neither states conditions for use nor names sibling tools to route around.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does add one useful trait: 'Page content is not stored,' which addresses retention. However, it does not disclose whether a network request occurs, how redirects are handled, or that the many optional parameters are discarded, 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?

Two short sentences with the core output front-loaded and a useful privacy note second. Every sentence earns its place, though the brevity is achieved by omitting broader guidance.

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

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

For a tool with nine optional parameters and no output schema, the description is incomplete: it does not explain which parameters matter, what the return format looks like, or how this tool relates to sibling shape/URL tools. The schema covers parameter meanings but not selection or invocation strategy.

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 little beyond signaling that URL is the central input; the detailed parameter descriptions in the schema already carry the semantic weight.

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 ('Return') and a concrete result ('host, scheme, and HTTP status for a URL'), so the core purpose is clear. It does not explicitly differentiate from siblings like fetch-status or normalize-url, but the output trio gives enough shape for an agent to infer the main job.

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

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

There is no guidance about when to prefer this tool over alternatives, nor any mention of exclusions or related siblings. The only usage signal is the implied case of needing host/scheme/status for a URL, which is weak for a nine-parameter tool with 27 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 main description adds a meaningful privacy guarantee: 'No identifiers are retained.' Parameter descriptions reinforce this with notes like 'discarded after the shape check' and 'no disk access.' However, with no annotations, the description still fails to disclose whether network calls occur, how classification works, or what the return value contains.

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

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

The description is two short sentences, front-loaded with the core action and then adding the privacy guarantee. There is no wasted wording, but the terseness contributes to under-specification, so it is not fully appropriate.

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

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

With 9 optional parameters, no annotations, and no output schema, the description leaves major gaps: it does not explain how parameters combine, what classification result looks like, or which sibling tools are alternatives. An agent cannot confidently predict the tool's behavior or output.

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

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

All 9 parameters have detailed schema descriptions, so schema coverage is 100%. Those descriptions add semantics beyond parameter names, such as 'discarded after the check' and 'no disk access.' The main description adds no parameter-level value, so baseline 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 verb and object: 'Show how this request is classified.' However, it never defines what classification means, what output to expect, or how it differs from the many sibling shape/check tools. This is a vague purpose rather than a clear, differentiating one.

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 a specialized sibling like validate-json, domain-shape, or normalize-url. The privacy note implies a safe classification entry point, but that context 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?

No annotations are present, so the full burden falls on the description. It discloses the absence of WHOIS/ownership data, but does not say whether any network or side effects occur, what the output looks like, or how errors are handled. The schema's 'discarded' notes hint at statelessness, but the description itself provides little 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, front-loaded sentence with no filler. It states the core action immediately and includes a compact qualifier that adds useful 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 definition is incomplete for a tool with seven input parameters and no output schema. It names only hostname behavior and never reconciles the other six schema properties with the stated purpose, nor does it describe return format or failure behavior. The schema's discard notes partially compensate, but the description itself leaves significant gaps.

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 good descriptions for all parameters, including which ones are discarded, so the baseline is a 3. The description maps the concept 'hostname' to the tool's purpose but does not clarify why the schema contains ref, url, city, feed, json, and path, nor does it add meaningful parameter-level detail 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 ('split') and clearly names the resource ('hostname') and outcome ('labels'). It also draws a boundary by stating it does not provide WHOIS or ownership data. It doesn't explicitly distinguish from sibling tools, but the hostname focus is enough to be serviceable.

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

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

There is no guidance on when to use this tool versus alternatives like normalize-url, github-repo-shape, or web-fetch. The 'without WHOIS or ownership data' phrase implies a boundary, but it does not state when to choose this tool or when to avoid it.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal the HTTP method and the limited return value, which is useful, but it does not explain behavior for the other eight parameters, possible side effects, error handling, or why several parameters are described as 'discarded' in the 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 a single, front-loaded sentence with no redundancy. It states the action and the limited return value efficiently, and 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 annotations, and no output schema, a one-line description is insufficient. The agent is left uncertain about which parameter to use, whether other parameters are alternatives or ignored, what the exact response shape is, and how this tool fits among the many 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?

Schema description coverage is 100%, so every parameter is already documented in the schema. The description adds only the 'public URL' framing and 'status only' return scope, not meaningful parameter-level semantics beyond what the schema provides, so the baseline of 3 applies.

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

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

The description clearly identifies a specific action ('HEAD a public URL') and return scope ('status only'), and this distinguishes it from content-fetching siblings like web-fetch or browser-url-ok. However, it does not account for the many non-URL parameters in the schema, so the stated purpose is clear but incomplete relative to the tool's apparent surface.

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

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

No guidance is given about when to prefer fetch-status over related siblings such as normalize-url, browser-url-ok, or web-fetch, nor are exclusions or conditions stated. The phrase 'status only' implies a lightweight alternative to fetching full content, but that is left to inference rather than 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?

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose one meaningful behavior—the path is discarded—but it does not state what the tool returns, whether it validates or normalizes, or how it handles malformed or non-Figma URLs.

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 front-loaded and contains no filler: one main clause and a short behavioral note. It is mildly ambiguous whether 'Path discarded' refers to a URL path component or the 'path' input parameter, which prevents a 5.

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

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

The tool has nine accepted parameters, no annotations, and no output schema, yet the description explains neither the return value nor how the other schema fields relate to the tool. An agent could select the tool, but not confidently predict the result of invoking it.

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

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

Schema description coverage is 100%, so the baseline is 3; each parameter already has a descriptive comment. The description adds no new parameter-level meaning and only echoes the path-discard behavior already present in the schema's 'path' parameter.

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

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

States a specific verb ('Parse') on a specific resource ('a Figma file URL') and adds a behavioral corollary ('Path discarded'). The Figma qualifier clearly differentiates it from sibling shape tools such as github-repo-shape, jira-key-shape, and 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?

The description gives a clear domain constraint: this tool is for Figma file URLs. An agent can route Figma URL-parsing tasks here rather than to general URL tools like normalize-url, though no alternatives or explicit exclusions are named.

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 state 'No disk access,' which is a useful safety signal, but it does not disclose what the tool returns, whether it can throw errors, what criteria define 'safe,' or what happens with invalid inputs. For a tool that performs a check, this is a significant gap.

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

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

The description is exceptionally concise, with exactly two short sentences that both carry meaning. The keyword 'path' appears first and the safety note is quickly stated. It is front-loaded and easy to scan, though it could afford slightly more detail without becoming bloated.

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 100% schema coverage, the description is incomplete for an agent. There is no output schema, so the return value is not explained. The tool has nine parameters yet the description only references 'path,' and the meaning of 'looks safe' is undefined. An agent cannot determine what result to expect or how to interpret the tool's output.

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 fully documents all nine parameters. The description adds no parameter-specific meaning beyond mentioning 'path,' and given the large parameter list, it does not help clarify which parameters are actually relevant to the path check. Baseline 3 is appropriate because the schema handles the 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 clearly states a specific action ('Check') on a specific resource ('whether a path looks safe'), and the added 'No disk access' distinguishes it from URL-checking siblings like browser-url-ok and playwright-url-ok. However, 'safe' remains vague, leaving the exact nature of the check ambiguous.

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

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

No guidance is given on when to use this tool versus alternatives. Sibling tools like normalize-url, browser-url-ok, and fetch-status clearly relate to URL handling, but the description does not explicitly say 'use this for path strings, not URLs' or mention any exclusions. The only hint is 'No disk access,' which implies a static check but does not help with 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?

No annotations are present, so the description carries the full burden of behavioral disclosure. It only indicates an external service via 'Open-Meteo' but does not mention network calls, approximate results, or that most inputs are discarded. The schema hints at discarding, but the description itself remains opaque about side effects and limits.

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 filler. It conveys the core purpose efficiently.

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

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

The tool has 9 optional parameters, no required parameters, no output schema, and no annotations, yet the description gives almost no contextual guidance. It does not explain which parameter to provide, what the response format is, or why the other parameters exist, leaving agents likely to misuse or underuse the tool.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the tool description adds no parameter-level meaning. The description does not clarify that 'city' is the relevant parameter for the stated place lookup, so it adds no extra 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 states a specific resource and result: latitude and longitude for a place, sourced via Open-Meteo. This distinguishes it from siblings like weather-hint and timezone, though it does not explicitly name those alternatives.

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

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

The description gives no explicit guidance on when to use geo-hint versus weather-hint or timezone, and no exclusions. The intended use is only implied by the purpose statement, which is insufficient given the 9 unrelated optional parameters.

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

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

No annotations are present, so the description carries the full behavioral burden. It does not disclose whether the URL is fetched or parsed locally, what the parsed output looks like, or that many schema parameters are discarded after validation; the schema property descriptions hint at this, but the tool description itself 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?

A single, front-loaded sentence with no wasted words. It conveys the core purpose immediately and is as concise as a tool description 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?

With nine parameters and no output schema, the description is too thin to be fully actionable. It omits the return shape, which parameters are actually relevant, and how this tool relates to the many sibling URL/shape tools, leaving an agent to guess at important invocation details.

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 every parameter already has a description in the schema. The tool description adds little parameter-level meaning beyond identifying the URL as a GitHub URL, which fits the baseline 3 for high schema coverage.

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

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

The description uses a specific verb and resource: 'Parse owner and repo from a GitHub URL.' This clearly states what the tool does and is distinguishable from sibling tools like domain-shape or jira-key-shape by its GitHub URL scope.

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

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

There is no guidance about when to use this tool versus sibling shape/URL tools, nor any mention of alternatives or exclusions. An agent must infer from the name and description that this tool is only meant for GitHub repository URLs.

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 that titles are discarded and the result is only a count, which is useful. However, it does not mention that this is a live network fetch, possible failure modes, or that optional arguments appear to be ignored.

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

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

Two short sentences with the action front-loaded and no filler. 'Titles discarded' earns its place by setting output expectations.

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

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

The description is too thin given 9 optional parameters, no annotations, and no output schema. It does not explain that no arguments are needed (or that arguments are effectively ignored), nor describe what a successful response contains beyond a count.

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; the tool description adds no parameter-level meaning. It does clarify that titles are not part of the count, but this is already echoed in the 'feed' parameter description.

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 action ('Count') and a clear resource ('current Hacker News front-page stories'), and adds a distinguishing output constraint ('Titles discarded') that separates it from generic fetch tools. There is no ambiguity about what the tool does.

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

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

The description implies the tool should be used when a count of current HN front-page stories is needed, but it does not state when not to use it or name alternative tools such as web-fetch for retrieving titles. Usage context is present only by inference.

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

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

With no annotations, the description must carry the behavioral burden. It only states the tool provides 'names for clock calls,' with no disclosure of whether the tool returns a list, validates input, performs a read-only lookup, or has side effects. The actual behavior is left entirely 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 short and contains no filler, but it is under-specified relative to the tool's eight parameters and unclear purpose. It is concise but not appropriately proportioned to the tool's apparent complexity, preventing a higher 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?

There is no output schema and the description does not explain what the tool does with the diverse parameter set or what form the timezone names take. An agent would struggle to know how to call this tool correctly or interpret its results, so the description is materially incomplete.

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

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

The input schema provides descriptions for every parameter, so the baseline is 3 even though the description adds no parameter-level meaning. The description does not connect the listed parameters (ref, url, city, etc.) to timezone names, leaving an unexplained gap, but the schema itself covers the mechanics.

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

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

The description identifies the resource as 'Common IANA timezone names for clock calls,' which conveys the subject matter but lacks a verb or explicit action (e.g., returns, lists, validates). It also doesn't distinguish this tool from sibling tools like 'timezone' or 'utc-time' that also relate to timezones.

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' gives a hint about when the tool might be used, but there is no explicit guidance on when to choose this tool over alternatives, when not to use it, or any prerequisites. The description offers no exclusion or comparison to 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 word 'Fetch' and 'public' suggest a read-only network operation, and 'group counts only' limits the output. However, with no annotations provided, the description does not disclose error behavior, redirect handling, missing robots.txt handling, rate limits, or any other side effects beyond the minimal statement.

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

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

The description is one tight sentence with no filler or redundant wording. It is concise, but it sacrifices necessary context about parameters and 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 9 optional parameters, no output schema, and no annotations, the description is far from complete. It does not explain which parameter supplies the target host/URL, what 'group counts' means exactly, or what the result shape looks like, so an agent cannot reliably call this tool.

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

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

Although every parameter has a description, most descriptions are clearly unrelated placeholders or generic examples (e.g., 'Git ref name; discarded after the shape check', 'City name for a public weather hint', 'JSON text to validate; discarded after the check'). None of them coherently explain how the 9 optional parameters map to fetching and counting robots.txt groups.

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 ('Fetch'), a clear resource ('a public robots.txt'), and a constrained output ('return group counts only'). This gives an agent a solid high-level understanding of the tool's core 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?

The description provides no guidance on when to use this tool versus the many sibling tools like web-fetch, normalize-url, or domain-shape. There is no mention of preferred input, fallback behavior, or conditions that would make this tool the right choice.

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

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

There are no annotations, so the description carries the transparency burden. 'Key discarded' communicates a useful side-effect guarantee, and 'Check' implies a read-only validation. However, it does not disclose what the tool returns, whether invalid keys produce errors, or any other runtime behavior, leaving the transparency 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?

The description is brief and front-loaded, with no filler words. Both sentences are short and earn some place, but the terseness comes at the cost of essential information about which input to use. Brevity is not effective when it leaves the agent unable to invoke the tool correctly.

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 large, heterogeneous input schema, no annotations, and no output schema, so the description needs to do substantial work. It fails to state which property is the Jira key, what the validation result looks like, or how this differs from sibling shape validators. A one-line description cannot adequately cover this context.

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

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

The description never identifies which input schema parameter contains the Jira issue key. The schema lists seven unrelated properties—ref, url, city, feed, host, json, path—and none is named 'key' or described in terms of Jira. 'Key discarded' does not map to any parameter, so an agent cannot determine what to pass. The core semantic connection between the tool's purpose and its inputs is entirely missing.

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

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

The description states a specific verb and resource: 'Check a Jira issue key shape.' This clearly distinguishes the tool from sibling shape tools like github-repo-shape or domain-shape by naming Jira specifically. It does not explicitly name a sibling tool, and 'key shape' largely restates the tool name, so it stops short of a perfect score.

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

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

The description gives no guidance on when to use this tool versus siblings such as github-repo-shape, figma-url-shape, or validate-json. It does not mention acceptable input formats, when the check is appropriate, or any exclusions. The only additional sentence, 'Key discarded,' is about retention, not usage context.

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

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

With no annotations, the description carries the transparency burden, but it only discloses that the body is discarded. It does not mention network access, side effects, authentication, rate limits, or read-only guarantees.

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 key output and behavioral clarification are front-loaded, making the description appropriately concise.

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

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

Despite the schema having 9 optional parameters and no output schema, the description does not explain the output format, which parameters to provide, or how it differs from similar fetch/status tools. It is too minimal to fully guide an agent.

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

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

Schema descriptions cover all 9 parameters, so the baseline is 3. The tool description adds no parameter-specific meaning and leaves unclear which parameters are actually used, but it does not contradict 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 identifies the tool's output (HTTP status) and target input (public library docs URL), but it lacks an explicit verb and does not specify how it differs from sibling status tools. It is somewhat clear but not fully precise.

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

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

There is no guidance on when to use this tool versus alternatives like fetch-status, browser-url-ok, or web-fetch. The note 'Body discarded' hints at status-only usage but does not state conditions or exclusions.

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

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

With no annotations, the description carries the full behavioral burden. 'Values discarded' is a genuinely useful behavioral disclosure that tells the agent values are irrelevant and no value-based persistence is expected. Still, it does not state the output format, error behavior, or whether nested keys are counted, 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 two short sentences with the main action front-loaded and no filler. Both sentences earn their place: one states the purpose, the other states the key side effect.

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

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

For a tool with 9 optional parameters, no annotations, no output schema, and a large sibling set, this description is not complete enough to guarantee correct invocation. An agent cannot tell which parameter carries the JSON object to count, what the return value looks like, or how missing or invalid input is handled.

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 little parameter-specific meaning beyond saying values are discarded; in particular, it does not clarify whether the 'JSON object' is one of the 9 string parameters or the set of supplied arguments itself. The schema is complete but the description does not bridge the gap to the parameters.

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

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

The description clearly identifies a specific operation ('Count keys') and a target ('a JSON object'), and it adds a meaningful side-effect qualifier ('Values discarded'). It is substantially clearer than a tautology, but it does not differentiate this tool from siblings like validate-json or other shape-check tools, and the 'memory' aspect in the tool name is not explained.

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 know the number of keys in a JSON object and does not care about values. However, it does not explicitly state when to prefer this over sibling tools such as validate-json, nor does it provide exclusions or alternative routing 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?

No annotations are present, so the description carries the full burden of behavioral disclosure. It does usefully state that query and fragment are dropped, but it fails to explain behavior around the many unrelated schema parameters (feed, json, include_secrets, pagination, format, etc.), invalid URLs, return format, or whether the operation has side effects. This leaves significant behavioral ambiguity.

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

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

The description is two short sentences with no filler. The main output behavior is front-loaded, and the additional query/fragment dropping detail is placed second. For the core operation described, this is appropriately terse.

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 surprisingly large input schema (15 parameters), no output schema, and no annotations, yet the description only explains the core URL behavior. It does not address how the extra parameters are treated, what the return value structure looks like, error handling, or any side effects. An agent would need to make several assumptions before calling it confidently.

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

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

The input schema provides descriptions for all 15 parameters, so schema coverage is high and the baseline is 3. The description adds little beyond reinforcing that a URL is the primary input and that its query/fragment are removed; it does not clarify why unrelated parameters like city, feed, or json appear in the schema, nor how they relate to normalization.

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 resource ('a URL') and names the exact outputs (origin, host, path), with a clear note that query and fragment are dropped. It is not vague or tautological, but it does not explicitly differentiate itself from sibling URL-related tools such as browser-url-ok or figma-url-shape, 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, no mention of exclusions, and no routing to a sibling tool when different behavior is needed. The only usage cue is indirect: if you need origin, host, and path, this tool provides them. That is insufficient for confident tool selection among the large sibling set.

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 reveals that no browser is launched. It does not clarify whether the tool performs a network request, validates URL syntax only, or what 'can be opened' actually means, leaving significant behavioral ambiguity.

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

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

The description is two short sentences and front-loads the core action before the behavioral qualifier. It is efficient and free of fluff, though the brevity sacrifices important 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?

For a tool with nine optional parameters, no annotations, and no output schema, a short description is not enough to tell an agent which parameter to supply or what result to expect. The return value, actual check semantics, and parameter-selection logic are all unspecified.

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

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

Schema description coverage is 100%, so each parameter already has a meaningful description, including notes that values are 'discarded after the check.' The tool description adds no parameter-level meaning and does not indicate that 'url' is the primary parameter among the nine, so it neither improves nor harms parameter semantics.

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

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

The description states a specific action ('Check whether a URL can be opened') and a resource ('URL'), and 'No browser is launched' helps distinguish it from the sibling browser-url-ok. However, it focuses only on URL checking while the schema exposes nine unrelated parameters, so the purpose is not fully aligned with the tool's actual surface.

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

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

The phrase 'No browser is launched' implies a use case where browser automation should be avoided, which is a useful contrast with browser-url-ok. But it never explicitly names alternatives or states when to choose this over fetch-status, web-fetch, or normalize-url, so the usage guidance is 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 at least discloses that the input is discarded after use, indicating a non-persistent operation. However, it does not describe the return value, error behavior, or how invalid inputs are handled, so the behavioral disclosure is only partial.

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

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

The description is only two short sentences with no filler. The action and side-effect statement are front-loaded, though the missing mapping to inputs prevents a perfect conciseness 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?

Given seven parameters, no annotations, and no output schema, the definition is incomplete: it fails to specify which parameter carries the query, what the returned count represents, and what happens on invalid input. An agent cannot confidently invoke 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 descriptions cover all seven parameters, so the baseline is 3, but the tool description itself adds no parameter-level meaning. It references a 'search query' that does not map to any of the schema properties, which actively confuses parameter selection.

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, counting characters in a search query, but the input schema exposes seven unrelated parameters (ref, url, city, feed, host, json, path) with no 'query' property. It does not tie the action to any of the actual inputs, and there is no differentiation from sibling shape-check tools. This is closer to misleading than to a usable purpose 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?

No guidance is given for when to use this tool instead of a sibling such as validate-json, normalize-url, or web-fetch. The single sentence neither states conditions nor exclusions, leaving the agent to guess which input is a 'search query'.

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 disclosing behavior. It says only 'Short catalog of common HTTP status codes' and is silent on side effects, read-only status, discard behavior, or whether inputs are actually used.

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

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

The description is extremely concise, but this is under-specification rather than good concision. For a tool with seven distinct parameters and ambiguous purpose, one vague noun phrase is not 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?

With no output schema, no annotations, and no explanation of how the parameters relate to the catalog, the description is far too incomplete for an agent to invoke the tool correctly. It does not say what the tool returns or whether the inputs affect the output.

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 gives each of the seven parameters a description, including notes like 'discarded after the shape check' and 'no disk access,' so schema coverage is high. The tool description adds no parameter-level meaning or connection between the parameters and the catalog claim.

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 reads as 'Short catalog of common HTTP status codes,' which is a noun phrase and mostly restates the tool name rather than specifying a verb and resource. It gives no hint about what the call does with the seven heterogeneous inputs or what the agent should expect back.

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, when not to use it, or how it differs from sibling tools such as fetch-status or web-fetch. The agent is left to infer the intended context from the tool name and sparse 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 behavioral disclosure burden. It only mentions that the prompt is discarded and does not clarify side effects, return structure, or what happens with the seven input parameters. The schema hints at discarding behavior, but the description itself is too thin.

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

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

The description is only two sentences and has no filler. The core action is front-loaded and the data-handling note is brief. It is concise, though the brevity comes at the cost of useful 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?

For a tool with seven parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain the template's format, the role of the parameters, whether inputs are required, or what the agent should expect as a return value. An agent could not reliably invoke this tool correctly based on this definition.

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

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

The input schema describes all seven parameters individually with more than 80% coverage, so the baseline is 3. The description adds no additional parameter meaning and does not clarify why so many unrelated parameters exist or which are required.

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

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

The description states a specific action and outcome: 'Return a three-step thinking template.' This is clear enough for an agent to understand the basic resource involved. However, it does not differentiate from siblings or explain what 'thinking template' means 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?

There is no guidance on when to use this tool versus any of the many siblings. The phrase 'Prompt discarded' provides no contextual trigger or exclusion criteria, so an agent has no basis for choosing this tool over 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?

There are no annotations to cover safety or side effects, so the description carries the full burden. It only implies a read-only operation ('current time') and does not mention that most input parameters are discarded or that a timezone name must be provided. This minimal disclosure is insufficient for a tool with such a complex input 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 a single concise sentence, which satisfies the structural preference for brevity. However, it is under-specified relative to the tool's complexity, leaving major gaps that a longer description would be expected to fill.

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 absence of annotations and output schema, the description must explain how to invoke the tool correctly, but it does not. The mismatch between the described functionality and the actual parameters means an agent cannot determine the required input, making the description completely inadequate for reliable use.

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

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

The description mentions 'named IANA timezone,' but the input schema contains eight parameters (ref, url, city, feed, host, json, path) with no timezone-related field. The description does not clarify which parameter specifies the timezone, adding no meaning beyond the schema and actively misleading the agent about the tool's actual 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 states a specific verb and resource: 'Current time in a named IANA timezone.' This clearly identifies the tool's function. However, it does not explicitly differentiate it from the sibling tool 'utc-time,' which may also return current time, though 'named IANA timezone' suggests a distinct parameterized lookup.

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. The description gives only the basic function without mention of conditions, exclusions, or prerequisites, so an agent has no information about when to select this over utc-time or iana-zones.

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

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

With no annotations, the description must carry the burden of behavioral disclosure. It only states the output and fails to disclose that all nine input schema properties are effectively ignored, as their schema descriptions say they are 'discarded'. This is a significant behavioral trait for a tool whose schema suggests multiple possible inputs.

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

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

The description is a single sentence with no filler or redundancy. It is front-loaded and easy to parse, though very brief; it could earn a 5 if it included a bit more context, but as a concise statement of output it is appropriately small.

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

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

For a tool with no output schema and no annotations, the description should clarify the return format and the role of the nine input parameters. It only says 'Current UTC timestamp', leaving the agent unsure whether to pass arguments and what exact format to expect.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself adds no parameter meaning, but the schema's per-parameter notes already document that these inputs do not affect the result.

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

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

The description clearly identifies the tool's output as the current UTC timestamp, which is a specific and unambiguous resource. However, it is a noun phrase rather than a verb+resource construction, and it does not explicitly distinguish this tool from siblings like timezone or iana-zones, 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 usage context is provided. The description does not explain when to prefer this tool over the timezone or iana-zones siblings, nor does it state that the tool needs no meaningful arguments. An agent is left to infer the appropriate invocation context.

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

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

With no annotations, the description carries the burden and does disclose a useful behavioral trait: 'The body is discarded.' However, it omits the return value/format and error behavior, so transparency is partial.

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

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

Two short sentences front-load the action and contain no filler. The description is appropriately brief for a straightforward validator.

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 7-parameter schema: it never identifies the 'json' parameter as the body to validate, and it does not state the result format. The unrelated-looking parameters (ref, url, city, feed, host, path) could confuse an agent, and there is no output schema to fill the 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?

Every property in the input schema has its own description (100% coverage), so the baseline is 3. The main description adds no parameter detail beyond calling the input a 'body,' but the schema provides the necessary parameter meanings.

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 body is valid JSON.' It clearly states the tool's core function, though it does not explicitly distinguish it from sibling shape/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?

No when-to-use guidance or alternatives are provided; the description gives no prerequisites, exclusions, or conditions. The intended use is only implied by the tool name and the 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals only that the tool fetches from Open-Meteo and returns a temperature; it does not mention units, error behavior, network dependence, rate limits, or whether the operation is read-only.

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 terse and front-loaded, but it is not appropriately sized for a tool whose schema includes seven parameters and no annotations. It is concise to the point of under-specification rather than efficiently complete.

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

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

Given the seven-parameter schema, no annotations, and no output schema, this description is grossly incomplete. An agent cannot reliably determine required inputs, expected output format, or failure conditions from this 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 'city', which aligns with the city param, but the input schema contains many other params (ref, url, feed, host, json, path) with no guidance about which are actually needed or ignored. With a large number of undocumented-in-description params, the description fails to compensate for the ambiguity.

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

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

The description states a specific action and resource: it returns the current temperature for a city and identifies Open-Meteo as the data source. This is clear and distinct from the sibling tools, though it does not explicitly contrast itself with any alternative weather tool.

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

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

The description implies the usage context: use this tool when you need a city's current temperature. However, it gives no explicit guidance about when not to use it, no prerequisites, and does not mention alternatives among the sibling tools.

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

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

With no annotations, the description carries the disclosure burden and does so by naming the two returned fields and explicitly stating that the body is discarded. It also scopes usage to public URLs, implying no auth requirements. Redirects, timeouts, and error behavior are not covered, but they are secondary for this simple read operation.

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 behavior is front-loaded and the key caveat 'Body discarded' is stated immediately. 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 basics are present: what is returned and that the body is discarded. However, with nine optional parameters, no output schema, no annotations, and a sibling list containing closely related tools, the description does not explain response shape, error behavior, or how to choose between web-fetch and alternatives. Those are noticeable gaps.

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

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

Schema description coverage is 100%, so each parameter already has documentation and the baseline is 3. The tool description adds no parameter-level detail and does not explain how the eight non-URL optional parameters relate to the stated behavior. The schema's `url` description partially covers the main input, but it says 'normalize or cite' rather than explicitly 'fetch status and content type'.

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 reports HTTP status and content type for a public URL, and it explicitly says the body is discarded. This distinguishes it from a general content-fetching tool. It does not explicitly contrast with sibling fetch-status, though the content-type mention adds some differentiation.

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

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

The phrase 'for a public URL' implies public, unauthenticated targets, and 'Body discarded' warns against using this tool when body content is needed. However, it never names alternatives such as fetch-status or browser-url-ok, so routing between closely related siblings is only implied.

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. It discloses one behavioral trait: 'Title discarded after the call,' implying the tool is stateless and does not retain input. It does not disclose whether the tool makes a network request, how it handles nonexistent titles, or what it returns, so transparency remains 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 short and front-loads the main purpose in its first sentence. The second sentence adds a statelessness hint, though it is vague and partly duplicates the schema's repeated 'discarded' notes. Overall, it is economical without being wordy.

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 far too thin to support correct invocation. It omits which property receives the Wikipedia title, what the return value means, and how the tool behaves in edge cases such as invalid titles or redirects.

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

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

The schema documents seven string parameters, but none of them is a Wikipedia title, and the description never maps 'title' to any parameter. The schema fields are refs, URLs, cities, feeds, hosts, JSON, and paths, which creates a direct usability mismatch: an agent cannot determine what value to pass. This is actively confusing rather than merely lacking 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 gives a specific verb and resource: 'Check whether a Wikipedia title exists.' This is clear and distinguishes the tool from most sibling validators by naming Wikipedia titles as the domain. However, it does not explain the relationship between this purpose and the unrelated-looking input parameters.

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

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

There is no explicit guidance about when to use this tool instead of sibling tools such as normalize-url, validate-json, or file-path-ok. The intended use case is only weakly implied by the one-line description, and no exclusions, prerequisites, or alternative conditions are provided.

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