ISO country NO

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

No annotations are provided, so the description carries the burden. It usefully discloses that task text is discarded and that the result is informational content, but it does not mention side effects, cost implications, errors, or behavior when no matching gateway is found.

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: purpose, return value, and a key behavioral note. The description is tight, front-loaded, and every sentence adds information without redundancy.

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

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

The description lists what is returned and notes discarded task text, but with 9 optional parameters and no output schema, an agent still lacks guidance on what to pass (if anything) and how the tool determines results. More context about invocation or fallback behavior would be needed for full completeness.

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 is individually described and many include the important 'discarded after shape check' note. The main description adds only the high-level 'task text discarded' clarification; it does not explain how the parameters relate to finding the gateway.

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 ('Find'), resource ('public pay-per-call tool gateway (Monid)'), and output ('CLI setup, how-it-works, skill file, and remote MCP hops'). This is distinct from sibling tools like validate-json or normalize-url, so an agent can tell it apart without inspecting schemas.

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

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

The description implies the tool is for discovering/retrieving Monid gateway documentation, and the sibling list shows it is not a validator or check. However, there are no explicit when-to-use or when-not-to-use conditions, and no alternative tools 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 provided, the description carries the full disclosure burden. It reveals one meaningful behavioral constraint: no browser is launched, signaling a non-invasive check. But it does not clarify whether the check is purely syntactic, whether it makes network requests, or what 'can be opened' concretely means, which leaves important 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?

The description is two short sentences with zero filler. The core action is front-loaded, and the most important constraint, 'No browser is launched,' follows 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 tool has a 9-parameter schema and no output schema, yet the description explains neither what 'can be opened' means nor what the tool returns. The presence of unrelated parameters (city, feed, json, path) is unexplained, and the agent is left to guess the expected input and result format. For a tool with no annotations, this is inadequate.

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 9 string parameters, including notes about being 'discarded after the shape check,' so schema coverage is 100%. The tool description adds nothing about which parameter is the primary one (presumably 'url') or why seemingly unrelated parameters exist, but the schema already does 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 states a specific action and resource: 'Check whether a URL can be opened.' The second sentence, 'No browser is launched,' clearly distinguishes this tool from sibling tools like playwright-url-ok that do launch a browser, so the agent can tell this tool apart without opening schemas.

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

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

The description implies this is a lightweight, side-effect-free check by noting 'No browser is launched,' which gives some contextual signal for when to use it. However, it never explicitly names alternative tools or states conditions for choosing this over normalize-url, fetch-status, or playwright-url-ok, leaving selection largely to inference.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does reveal that the expression is discarded, indicating no persistence, but it does not disclose what is returned, whether evaluation produces a numeric result, error behavior, or side effects. This is insufficient for a tool with no output schema.

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

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

The description is extremely brief and front-loads the core action. There is no fluff or redundant restatement. The second clause is terse but contributes a behavioral note; the main weakness is not verbosity but missing semantic connection.

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

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

The tool has 9 parameters, no output schema, no annotations, and a description that omits both the return contract and the parameter to use for the expression. The agent cannot reliably select or invoke this tool, so the description is far from contextually complete.

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

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

Although schema_description_coverage is 100%, all nine parameters describe unrelated concerns such as URLs, hosts, JSON text, paths, and search text. None of them is an arithmetic expression, and the description never maps 'a+b' to any parameter. An agent cannot determine how to pass the expression, making the tool practically unusable.

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') and a specific resource ('a+b style arithmetic'), which distinguishes it from the sibling shape/status/search tools. However, the second sentence 'Expression discarded' leaves the result of evaluation unspecified, so the purpose is clear but not fully actionable.

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 sibling, nor any conditions, exclusions, or alternatives. The description only implies that arithmetic evaluation is the use case; it does not say when this tool is preferable or what disqualifies a request.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It adds a meaningful privacy trait: 'Page content is not stored.' It does not mention network behavior, redirects, or that many input fields are discarded, but it does establish a read-only, non-persistent profile.

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 function is front-loaded and the privacy note earns its place as a behavioral clarification.

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 full schema descriptions, the tool has 9 parameters, 0 required parameters, no output schema, and no annotations. The description does not explain why so many unrelated parameters exist, which parameter should actually be supplied, or what the response structure looks like. This is incomplete for safe autonomous 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 already has 100% description coverage, so the baseline is 3. The description itself adds no parameter-level guidance beyond implying the url parameter is the relevant input, while the schema descriptions explain the other 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 action and resource: 'Return host, scheme, and HTTP status for a URL.' It does not explicitly compare against siblings like normalize-url or fetch-status, but the specific output combination makes its core purpose distinguishable.

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

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

The usage context is implied: use this tool when you need host, scheme, and HTTP status for a URL. However, it provides no explicit guidance on when not to use it or which sibling tool to prefer for overlapping needs.

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 full responsibility for behavioral disclosure. It does mention that no identifiers are retained, which is useful privacy context, but it does not explain whether the tool performs network calls, returns a category, or has side effects beyond classification.

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

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

The description is short and contains no redundant phrasing, but it is also under-specified. The first sentence is too vague to be actionable, and the second sentence only provides a privacy note. It is concise in length but not optimally structured for tool selection.

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

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

With no output schema, no annotations, and a complex 9-parameter tool, the description is incomplete. It fails to explain what the classification result looks like, how parameters relate to the classification, or when an agent should prefer this over the sibling tools.

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

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

The schema covers all 9 parameters with individual descriptions, including details about values being discarded or normalized. The description itself adds no additional parameter-level meaning, but since schema coverage is 100%, this is an acceptable 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 states a verb and object ('Show how this request is classified') and indicates a classification behavior. However, it never defines what classification categories or output the agent should expect, and it does not distinguish this tool from the many sibling shape-checking and 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?

There is no guidance about when to use this tool versus alternatives. With 27 sibling tools such as validate-json, normalize-url, domain-shape, and weather-hint, an agent cannot tell whether 'compatibility' is a router, a classifier, or a meta-utility that should be tried before those specific 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 full behavioral burden, but it only reports a parse action and excludes WHOIS/ownership data. It does not disclose that inputs are discarded after checks, what happens for invalid input, or whether any side effects occur; the schema-level 'discarded' notes are not part of the tool description.

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

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

The description is a single sentence with no filler. The action is front-loaded, and the limiting clause 'without WHOIS or ownership data' earns its place by setting expectations about 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?

For a tool with 9 optional parameters and no output schema, the definition is incomplete. It explains only the hostname case, gives no return-shape information, and leaves the purpose of the other eight accepted inputs unexplained in the description. The schema descriptions rescue parameter semantics but not overall tool behavior.

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

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

Schema description coverage is 100%, so the baseline is 3; the description does not need to explain every parameter. It adds no meaning beyond identifying host as the hostname, leaving the mapping of ref, city, feed, json, path, zone, and query to the schema descriptions alone.

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 ('split a hostname into labels') and a clear boundary ('without WHOIS or ownership data'), so the core purpose is recognizable. However, it only describes one of the nine schema inputs and does not reflect the broader shape-check behavior hinted at by params like ref, json, path, and query.

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

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

There is no explicit guidance on when to use this tool versus sibling tools such as normalize-url, fetch-status, or validate-json. The negative clause 'without WHOIS or ownership data' is the only hint, but it names no alternatives or selection conditions.

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

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

With no annotations provided, the description carries the behavioral burden. It explicitly discloses that this is a HEAD request, meaning no body is retrieved, and that only status is returned. It also scopes the operation to public URLs, implying no authentication or private access. It stops short of describing redirects, timeouts, or error behavior, so it is not fully 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, front-loaded sentence with no filler. Every word contributes meaning: the method (HEAD), the scope (public URL), and the output (status only). It is concise without being under-specified in its core claim.

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 gives no information about return format, what happens when no parameters are provided, or which parameter is actually used for the HEAD request. The schema's many unrelated parameters make the description incomplete for reliable agent invocation.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds no parameter-level detail beyond what the schema provides, which is acceptable but earns only the baseline score. The odd parameter descriptions, such as 'HTTPS URL to normalize or cite' for url, are not clarified by the tool 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 states a specific operation: HEAD a public URL and return only the status. This is clear and distinguishes it from content-fetching siblings like web-fetch. However, the input schema contains many unrelated optional parameters (city, json, zone, query, etc.), and the description does not reconcile those with the stated HTTP-status purpose, leaving the tool's full scope ambiguous.

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

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

The description implies the tool should be used when you need only the HTTP status of a public URL, but it gives no explicit when-to-use or when-not-to-use guidance and names no alternative tools such as browser-url-ok, playwright-url-ok, or web-fetch. It is adequate but leaves selection decisions mostly to the agent's 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?

No annotations are provided, so the description carries the full behavioral disclosure burden. It reveals one behavioral fact, 'Path discarded,' but does not state whether the tool validates, normalizes, returns extracted components, or rejects non-Figma URLs. 'Parse' implies a read-only operation, but the output contract and error behavior remain opaque.

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 compact, with no filler or repeated information. The core action is front-loaded and the extra note about discarding the path is functional. It is more under-specified than verbose, which is appropriate to reward under this dimension.

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, yet the schema unexpectedly includes nine unrelated parameters such as city, feed, host, json, zone, and query. The description does not explain how these relate to a Figma URL shape check, what the parsed result looks like, or how an agent should handle invalid input. This leaves too much to inference for confident invocation.

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

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

The input schema covers all nine parameters with individual descriptions, so the baseline is 3 even though the description itself adds no parameter-level detail. The phrase 'Path discarded' is ambiguous because the schema contains a 'path' parameter described as 'File path to check,' not necessarily the URL path.

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 a clear resource, 'a Figma file URL,' which establishes the tool's core domain. It also adds a behavioral detail, 'Path discarded,' that clarifies one aspect of the result. It does not explicitly distinguish itself from sibling URL/shape tools, but the 'Figma' specificity makes the purpose reasonably clear.

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

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

The phrase 'Parse a Figma file URL' implies when the tool should be used: when the agent has a Figma file URL to inspect or normalize, rather than a GitHub repo, Jira key, or general domain. However, it gives no explicit when-not-to-use instructions, prerequisites, or routing to alternatives, so the usage guidance 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?

The sentence 'No disk access' is a valuable explicit behavioral guarantee that goes beyond the name, indicating a read-only, side-effect-free check. However, with no annotations, the description still fails to disclose return values, error behavior, or how 'safe' is determined. It is partially transparent 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 with no filler; the core action is front-loaded and the key constraint is stated immediately after. Every word contributes meaning.

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

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

The tool has multiple schema properties, no output schema, and no annotations, but the description only covers the path aspect and the no-disk-access guarantee. It omits return-value semantics, the definition of 'safe', and the purpose of the unrelated accepted parameters, leaving the agent without enough context to invoke it confidently.

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

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

Schema description coverage is 100%, so the schema already documents every parameter including discard behavior, warranting a baseline of 3. The description adds little beyond emphasizing 'path' and does not clarify why the schema also accepts url, city, feed, host, json, and query, which creates some semantic mismatch.

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 ('a path'), plus a useful constraint ('No disk access'). It is distinguishable from URL-oriented siblings like browser-url-ok and normalize-url. However, 'safe' is left undefined, so the exact criterion is ambiguous.

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

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

The description gives no explicit when-to-use or when-not-to-use guidance and names no alternatives. 'No disk access' implies a pure shape check rather than a filesystem check, but it does not tell an agent when to choose this over related tools. Usage context must be inferred from the tool name alone.

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

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

No annotations are present, so the description carries the full disclosure burden. It mentions the Open-Meteo dependency but does not explain behavior with the nine optional parameters, what is returned, or why most inputs are described as discarded. This is too thin to anticipate tool behavior.

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

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

The description is a single, economical sentence with no filler; the output and source are front-loaded. It is concise to the point of under-specification, but that issue is captured in contextual completeness rather than conciseness.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, this description is severely incomplete: an agent cannot determine which parameter to provide, what the exact return shape is, or how the 'discarded' fields relate to the returned coordinates. More operational detail and an example are needed.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters and their discard behavior. The tool description adds only the 'place' concept and does not clarify which parameter, if any, selects the place, but it does not need to restate schema details.

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

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

The phrase 'Latitude and longitude for a place via Open-Meteo' clearly names the core deliverable (coordinates) and the data source, and the 'geo' scope differentiates it from weather- and time-oriented siblings. It lacks an explicit verb and does not name sibling alternatives, so it stops short of a 5.

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

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

There is no guidance on when to choose geo-hint over weather-hint, timezone, or other siblings, nor any instruction about what input indicates 'a place'. The intended use is only implied by the name and output phrase.

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 only says 'parse.' It does not state what happens for invalid or non-GitHub URLs, whether the URL is validated, what the return shape is, or that parameters other than the URL appear to be discarded. The generic schema entries like 'discarded after the shape check' add confusion rather than clarification.

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 wasted words; it states the action, input domain, and output concept immediately.

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

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

For a tool with nine optional parameters, no output schema, and no annotations, the one-sentence description is insufficient. It does not clarify the input contract, what owner/repo are returned as, or error behavior, so an agent cannot fully predict how to invoke or interpret 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. The description adds some meaning by clarifying that the relevant input is a GitHub URL and that owner/repo are the intended outputs, but it never explicitly names which of the nine optional parameters should be populated, and the schema's `url` description says 'HTTPS URL to normalize or cite' rather than 'GitHub URL to parse.'

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 the tool's function and, combined with the name 'github-repo-shape', distinguishes it from sibling shape tools like figma-url-shape and jira-key-shape.

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

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

The description implies a clear use case: use this tool when you have a GitHub URL and need owner/repo extracted. However, it gives no explicit when-not-to-use guidance or alternative routing among the many sibling URL/shape tools, so the agent must infer the boundary.

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 disclosure burden. It does disclose that titles are discarded and that this is a counting operation, but it does not mention whether network access is required, the exact return shape, or any failure behavior. Partial transparency beyond the bare purpose.

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 compact: one core action sentence followed by a short, meaningful caveat. There is no filler, and the main purpose is front-loaded.

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

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

For a simple count tool, the core purpose and output constraint are present, and the schema covers the odd optional parameters. However, the lack of an output schema or annotations leaves some ambiguity about the exact return format and whether any of the nine parameters can influence the count, so the description is adequate but not fully complete.

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

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

Schema coverage is 100%, so each parameter is already documented in the schema, and every parameter is described as optional or discarded. The tool description adds no parameter-level meaning, 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 names the action ('Count'), the exact resource ('current Hacker News front-page stories'), and the output constraint ('Titles discarded'). This distinguishes it from sibling tools like web-fetch or fetch-status, which retrieve content rather than return a numeric count.

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 use case: call this tool when you need the number of stories currently on the Hacker News front page. 'Titles discarded' is an implicit when-not: do not use it if story titles are needed, though no alternative tool is explicitly 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?

No annotations are provided, so the description must carry the behavioral disclosure burden. It only states what the data is, not that the tool is read-only, returns a static list, or that all optional parameters are discarded. The parameter descriptions in the schema hint at the discard behavior, but the description itself adds no 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 short sentence with no filler, and the core resource appears first. It is extremely concise and front-loaded, though it is also sparse in substantive 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?

With no annotations and no output schema, the one-liner leaves an agent unsure about invocation style, return shape, and whether this is a static catalog or a callable operation. The schema provides some context about discarded parameters, but the description is not complete enough for a tool with this many optional inputs and no other structured metadata.

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

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

Schema description coverage is 100%, with each parameter already explaining that it is discarded after the call. The outer description adds nothing about parameters and does not clarify that none are needed to obtain the timezone names. Baseline 3 is appropriate because the schema handles 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 names the resource ('IANA timezone names') and a use case ('for clock calls'), so an agent can infer the tool returns common timezone identifiers. It lacks an explicit verb like 'returns' and does not differentiate from clock-related siblings such as 'timezone' or 'utc-time', but it is still reasonably clear.

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

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

The phrase 'for clock calls' gives a general usage context, implying this tool is for obtaining timezone names to use with clock operations. However, there is no explicit when-to-use or when-not-to-use guidance, and no alternatives are named, leaving the choice 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?

Without annotations, the description carries the full burden, but it only says the fetch is public and returns counts. It does not explain which parameter selects the target, what happens on missing robots.txt, or why all nine schema parameters are marked as discarded after checks.

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

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

A single front-loaded sentence with no filler; it communicates the main action and output constraint efficiently. It loses a point only because the brevity omits essential invocation details.

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

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

For a tool with nine optional parameters, no required parameters, no output schema, and no annotations, this description is insufficient. An agent cannot determine how to invoke it correctly or what 'group counts' will look like.

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

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

Schema description coverage is 100%, so the baseline is 3; the tool description adds no parameter-level meaning. No parameter is identified as the robots.txt target, leaving 'url' versus 'host' ambiguous.

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 ('Fetch a public robots.txt') and specifies the return shape ('group counts only'), so the core purpose is clear. It does not explicitly differentiate from siblings such as web-fetch or fetch-status.

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

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

There is no guidance on when to choose this tool over the many sibling tools, nor any exclusions such as 'use web-fetch when full content is needed.' The phrase 'group counts only' hints at a limitation but does not state a usage policy.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It does say the 'Key discarded,' which is a useful non-retention detail, but it does not disclose whether the operation is read-only, what it returns, whether any network call is made, or what side effects could occur.

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

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

The description is very concise: two short sentences with the core action front-loaded. The second sentence 'Key discarded' adds some behavioral context but is cryptic, so it is not fully self-explanatory despite being lean.

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

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

The tool has no output schema, no annotations, nine optional parameters, and no explicit indication of which parameter is required for the check. The description does not explain return values, validation criteria, or how to supply the key, making it incomplete for reliable invocation.

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

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

Although schema coverage is 100%, the description mentions a 'key' but never maps it to any of the nine schema parameters; none of them is named 'key' or 'issue_key.' The schema parameters are generic strings like ref, url, host, and path, so an agent cannot confidently determine which parameter should hold the Jira key.

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 names the operation ('Check') and the resource ('a Jira issue key shape'), which distinguishes it from sibling shape-checkers like domain-shape or figma-url-shape. However, it does not define what 'shape' means or what a valid key looks like, leaving some ambiguity.

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

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

The description gives no explicit when-to-use guidance, no alternative tool references, and no exclusions. An agent must infer entirely from the name and the one-line description, which is minimal compared to the large sibling set of similar validators.

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 the body is discarded. It does not mention whether the tool follows redirects, requires authentication, makes a network request, or how the many unrelated input fields are handled.

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

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

The description is short, front-loaded, and free of filler. It is efficient, though it achieves conciseness by omitting important details.

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

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

The tool has nine parameters, no annotations, and no output schema, yet the description only mentions a URL and body discarding. It does not specify which parameter to supply, what the returned status looks like, or how the unrelated optional fields such as city, json, and query relate to the tool's behavior.

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 each parameter already has a description, which establishes a baseline of 3. The description adds no parameter-level detail and does not clarify which of the several URL-like fields (url, host, feed, path) should be used for the library docs URL.

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: return the HTTP status for a public library docs URL while discarding the body. However, the qualifier 'public library docs URL' is somewhat ambiguous and the description does not differentiate this tool from siblings like fetch-status or web-fetch.

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

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

There is no guidance about when to use this tool versus related tools such as fetch-status, browser-url-ok, or web-fetch. The single sentence provides no context, exclusions, or alternatives.

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

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

Without annotations, the description carries the burden of behavioral disclosure. It discloses that values are ignored ('Values discarded'), which is useful, but it does not describe the return format, behavior on invalid JSON, or whether the operation is read-only. These gaps matter because no output schema or annotations are present.

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

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

The description is two short sentences with no filler and the main action is front-loaded. Both sentences earn their 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 no output schema and no annotations, the description omits the return value and error behavior, and it does not identify which of the nine optional parameters supplies the JSON object. The lack of parameter mapping 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?

Schema coverage is 100%, so the schema already documents all parameters. The description adds no parameter-specific guidance beyond implying that a JSON object must be provided; the likely `json` parameter is described in the schema as 'JSON text to validate' rather than as a key-counting input, so the mapping is left to inference.

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: 'Count keys in a JSON object.' It conveys the core operation and is not a tautology. However, it does not explicitly differentiate this from siblings such as validate-json, and it does not state whether nested keys are counted.

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 intended use is implied by the description: call when a JSON object's key count is needed. There is no explicit when-not-to-use guidance or reference to alternatives, even though siblings like validate-json overlap in the JSON-handling domain.

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 burden of behavioral disclosure. It does disclose the output fields and the dropping of query/fragment, which is useful. It does not clarify that the other eight schema parameters are essentially irrelevant after checks, nor does it describe error behavior or 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?

Two sentences with no filler. The main purpose is front-loaded, and the dropped query/fragment detail is a meaningful behavioral qualifier. 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 description is adequate for the core task and defines the return value despite the absence of an output schema. However, it is lean given the 9-parameter schema and many sibling tools; it does not explicitly say that only `url` should be used or when to prefer this over other URL-related tools.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds little parameter-level meaning beyond implying the `url` parameter is the one being normalized; it does not compensate for the noisy optional parameters, but the schema already documents each one.

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

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

The description clearly states a specific verb and resource: return origin, host, and path for a URL. It also notes that query and fragment are dropped, which is a precise behavioral detail. It does not explicitly differentiate from sibling URL-related tools like browser-url-ok 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 intended use is implied: use this when you need normalized URL components without query or fragment. However, no alternatives are named, and there is no direct guidance about when not to use this tool versus 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 provided, the description carries the full burden of behavioral disclosure. It only reveals that no browser is launched; it does not state whether a network request is made, what side effects exist, what the result format is, or how failures are reported.

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 purpose is front-loaded, and the key behavioral constraint ('No browser is launched') is given its own 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?

Given nine optional parameters, no annotations, and no output schema, the description is not complete enough for an agent to confidently call the tool. It omits what the return value means, how the URL is checked, and what the additional parameters contribute.

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

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

The schema has 100% parameter description coverage, so the baseline is 3. The description adds little beyond saying a URL is checked, and it does not explain the roles of the other eight parameters or how they interact with the check.

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

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

The description states a specific action ('Check whether a URL can be opened') and identifies the resource. It also adds a distinguishing behavioral note ('No browser is launched') that helps separate it from browser-based siblings like browser-url-ok. However, it does not clarify what 'ok' means exactly or how it relates to the many other schema 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 when-to-use or when-not-to-use guidance, and no alternative tools are named. 'No browser is launched' hints at a lightweight check, but an agent cannot tell when to choose this over browser-url-ok, fetch-status, or web-fetch.

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

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

With no annotations present, the description carries the behavioral disclosure burden. 'Query discarded' usefully signals that the input is not retained and the operation has no lasting side effects, but the description does not state the return format, edge-case behavior, or whether only the 'query' parameter is considered. This is partial but not complete 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 short, front-loaded, and contains no filler or redundancy. It loses a point only because it is so terse that it omits useful context about the oddly large parameter list and expected return, though every sentence it does include earns its place.

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

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

For a simple counting tool, the description plus rich schema is mostly sufficient: the agent can infer it should pass 'query' and receive a character count. However, with no output schema, no annotations, and nine parameters that are mostly irrelevant to the stated purpose, a more explicit statement about return value and ignored parameters would make the tool fully self-contained.

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

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

All 9 parameters already have description text in the input schema, giving 100% schema description coverage, so the baseline applies. The tool description adds no extra parameter-level meaning beyond identifying the query as the search text, and the schema itself already documents that 'query' is discarded after the length check.

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

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

The description clearly states a specific action ('Count characters') and resource ('a search query'), so an agent can tell what the tool does without opening the schema. It does not explicitly distinguish this tool from sibling count-related tools, but the name and wording are unambiguous enough to earn slightly less than top marks.

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, and it names no sibling tools or exclusion conditions. The only implied usage is 'when you need to count characters in a search query', but no explicit 'use this instead of X' context is provided.

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

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

There are no meaningful annotations, so the description carries the full burden for behavioral disclosure. Calling something a 'catalog' is not enough to communicate side effects, output format, input handling, or failure modes, and the description reveals none of these.

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 single sentence is short and front-loaded, but it is under-specified rather than appropriately concise. For a tool with seven parameters and no supporting annotations, a one-clause noun phrase omits too much essential 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?

There is no output schema and no behavioral annotation, so the description needed to explain what the tool returns and how the parameters are used. Instead it provides only a label, making the tool effectively uninvocable from the definition alone.

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

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

The schema provides descriptions for all seven parameters, but the tool description offers no connection between those parameters and the stated catalog purpose. Fields like url, city, feed, json, and path appear unrelated to HTTP status codes, and nothing explains which parameter an agent should 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 is just a noun phrase, 'Short catalog of common HTTP status codes,' which essentially restates the tool name without saying what action the agent should take or what the tool returns. It adds only the HTTP-status domain but does not distinguish it from siblings like fetch-status or web-fetch.

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

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

No when-to-use guidance is provided. The description does not mention alternatives, exclusions, prerequisites, or how status-catalog relates to sibling tools such as fetch-status or web-fetch, leaving an agent with no basis for selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses one meaningful behavior: 'Prompt discarded,' indicating the input prompt will not influence the output. It does not describe whether the returned template is static, whether all parameters are ignored, or what side effects might occur, leaving some 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 wasted words. The primary action is front-loaded, and the second sentence adds a relevant behavioral caveat. Every sentence earns its place.

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

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

For a simple template-returning tool, the description is adequate but not complete. It does not state whether arguments are required, whether all parameters are ignored, or what the three-step template actually looks like. Since the schema marks all parameters optional and covers their descriptions, an agent could likely call the tool with no arguments, but the description itself leaves that implicit.

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

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

Schema description coverage is 100%, so the input schema already documents each parameter. The description adds essentially no parameter-level meaning beyond 'Prompt discarded,' which does not clarify how the nine optional parameters relate to the output. Baseline 3 is appropriate because the schema carries the 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 uses a specific verb and resource: 'Return a three-step thinking template.' It clearly states what the tool produces and avoids a tautology. It does not explicitly differentiate from sibling tools, though none of the sibling names suggest a competing template-returning tool, so the clarity is strong but not maximally explicit.

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 'Prompt discarded' implies that this tool is not meant for prompt-dependent processing and that the output is a fixed template, giving some usage context. However, it does not explicitly state when to use this tool versus alternatives, nor does it name any excluded use cases.

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 states the core behavior (current time in a named timezone) but does not mention whether the tool performs network access, how invalid timezone names are handled, whether it has side effects, or what format the time is returned in.

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 is concise and directly states the tool's purpose, though it is arguably too terse given the mismatched schema and lack of annotations.

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

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

The tool has nine parameters, no output schema, and no annotations, yet the description provides no parameter mapping, no return format, no error behavior, and no relationship to sibling tools. An agent cannot reliably determine how to call this tool correctly from the given 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 input schema lists nine parameters (ref, url, city, feed, host, json, path, q, topic), but none of them is a timezone name, and the description does not explain how to supply the 'named IANA timezone'. The city parameter is described as a weather hint, which is unrelated to timezone lookup. The mismatch between the description and the schema makes it impossible for an agent to know which parameter to populate.

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 resource ('named IANA timezone') and the implied action (return the current time). It distinguishes itself from siblings like utc-time and iana-zones by focusing on a named timezone rather than UTC or zone listing. However, it lacks an explicit verb and does not map to any visible schema parameter, so it is slightly less clear than a fully specific definition.

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

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

No explicit guidance is given about when to use this tool versus alternatives such as utc-time or iana-zones. The description only implies that it is for getting time in a named IANA timezone, but it does not state exclusions, preferred contexts, or how to choose among the many 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?

No annotations are provided, so the description carries the full burden. It only reveals that the tool returns the current UTC timestamp but does not disclose that the many input parameters are discarded or do not affect the result. An agent could mistakenly believe these parameters influence the 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 a single short sentence with no wasted words, appropriately sized for a trivial tool. It is front-loaded but omits a note about the unrelated parameters, which would have made it more 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?

Despite the large, unrelated input schema, the description explains nothing about why these parameters exist, what the exact return value looks like, or any call conventions. The mismatch between the tool's stated purpose and its schema makes this definition incomplete 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 documents every parameter, most with descriptions like 'discarded after the shape check' or 'no disk access,' so schema coverage is essentially complete. The description adds no meaning beyond the schema, but the schema itself clarifies the parameters' role; therefore the baseline score 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 'Current UTC timestamp' states a clear verb and resource, making the core function unambiguous. It distinguishes from the sibling 'timezone' by focusing on UTC, though it does not mention the output format or that the input parameters are irrelevant.

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 offers no guidance on when to use this tool versus alternatives like 'timezone' or the many other siblings. It is a bare statement with no contextual cues for selection.

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

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

With no annotations provided, the description carries the full behavioral burden. It does disclose a meaningful trait: the body is discarded, indicating a non-persistent, side-effect-free validation. However, it does not state what the tool returns, how invalid JSON is reported, or any 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?

The description is only two short sentences and is appropriately front-loaded. Every sentence contributes: the first states the action and target, the second adds an important discard behavior. There is no unnecessary 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?

The tool has no annotations, no output schema, and seven input properties, yet the description does not explain the expected return value, which parameter is actually the JSON body, or how invalid input is surfaced. This is too thin for an agent to confidently invoke the tool in varied contexts.

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 properties, giving high schema-level coverage, so the baseline is 3. The tool description adds no parameter-level meaning and does not clarify how the generic 'body' relates to the `json`, `path`, or other schema 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 uses a specific verb ('Check') and a clear resource ('whether a body is valid JSON'), which distinguishes it from siblings that validate URLs, domains, or file paths. However, it does not explicitly tie 'body' to the `json` parameter, leaving slight ambiguity about the exact input object.

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

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

The description gives no guidance on when to use this tool versus alternatives, and it does not mention any sibling tools or exclusions. The 'body is discarded' note hints that this is a transient validation-only operation, but it stops short of providing usable 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?

With no annotations provided, the description must carry the behavioral burden. It only mentions the Open-Meteo dependency, but does not disclose that several parameters are discarded or that the tool may ignore inputs other than 'city'. This is a significant transparency gap for a tool with 9 optional parameters.

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

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

The description is a single concise sentence that front-loads the core function and source with no filler. Every word is relevant.

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

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

The tool has 9 parameters with no required fields, no output schema, and no annotations, while the description only explains the weather intent. This leaves the agent uncertain about which parameter is essential for a successful call, what response to expect, and why the schema contains unrelated fields. The description is therefore incomplete for proper invocation.

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

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

Schema description coverage is 100%, so the schema already documents each parameter's purpose and the 'discarded after the shape check' semantics. The description adds no extra parameter meaning, meeting the baseline of 3.

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

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

The description clearly states the tool's function: retrieving the current temperature for a city, with the external source Open-Meteo. This distinguishes it from sibling hints like geo-hint or lib-docs-hint, though it lacks an explicit verb such as 'get' or 'return'.

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 use case: call this tool when you need the current temperature for a city. However, it offers no explicit exclusions or comparisons with sibling tools like web-fetch or geo-hint, leaving the agent to infer when this tool is preferable.

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

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

With no annotations, the description carries the behavioral disclosure burden. It does usefully disclose that the response body is discarded, which is a meaningful non-obvious behavior. However, it does not mention error behavior, redirects, auth limits, return shape, or that most schema 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?

The description is a single tightly written sentence with no filler. The key output (status/content type) is front-loaded, and the body-discarded caveat is included efficiently. It earns its place without wasting tokens.

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, no annotations, and many nearby sibling tools. The one-line description is insufficient to disambiguate which parameter matters and why the others exist, nor how this tool differs from fetch-status or browser-url-ok. The schema helps, but the description alone leaves important invocation context missing.

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

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

Schema description coverage is 100%, so the baseline is 3 and the schema already explains each parameter individually. The description adds no parameter-level meaning and does not clarify why parameters like city, ref, json, and zone coexist with url, which leaves semantic ambiguity about how the tool should be invoked.

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 and result: HTTP status and content type for a public URL, with the body discarded. This clearly distinguishes the tool from URL-normalization or browser-check siblings, though it does not explicitly name them. The large set of unrelated schema parameters slightly muddies the stated 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?

There is no guidance about when to prefer this tool over siblings like fetch-status, browser-url-ok, or normalize-url. The phrase 'Body discarded' implies not to use it when body content is needed, but no explicit when-to-use/when-not-to-use direction or alternatives are provided.

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

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

There are no annotations, so the description carries the full behavioral burden. It discloses one behavioral trait ('Title discarded after the call') and implies a read-only existence check, but it does not state response semantics, failure behavior, or side effects of the seven accepted parameters.

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

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

Two short sentences, with the main purpose front-loaded and no wasted verbiage. The second sentence is terse but unclear; it could be more explicit about what 'Title' refers to given the schema.

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

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

With no annotations and no output schema, the description should specify how to pass the title and what response indicates existence. It does neither, and the schema's unrelated parameters actively confuse rather than complete the picture.

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 references a 'title' that does not exist in the input schema; the seven actual parameters (ref, url, city, feed, host, json, path) are described in the schema but none captures a Wikipedia title. The description adds no parameter meaning, and the schema descriptions point to unrelated behaviors, making correct invocation impossible to determine.

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 Wikipedia title exists', which clearly identifies the tool's purpose and distinguishes it from sibling shape-checkers like file-path-ok or browser-url-ok. However, the second sentence 'Title discarded after the call' introduces ambiguity by naming 'Title' as though it were an input, while the schema contains no title parameter.

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

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

The main clause implies the use case: invoke this tool when an existence check for a Wikipedia title is needed. It provides no explicit when-not guidance and does not reference alternative tools such as web-fetch or search-query-len.

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