America/Indiana/Indianapolis clock

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

With no annotations provided, the description must carry behavioral disclosure. It does reveal that task text and several inputs are discarded, which is useful privacy-relevant behavior. However, it does not state whether the tool performs network calls, is read-only, has rate limits, or what 'shape check' entails, leaving notable 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?

Two sentences with no filler. The core purpose and key outputs are front-loaded, and the privacy-relevant discarding behavior is stated explicitly. 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?

The tool has seven heterogeneous string parameters and no output schema, yet the description does not explain how the parameters map to the lookup, what to pass, or what 'Monid' is. While the return types are named, the lack of invocation guidance makes the description incomplete for reliable selection and 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 input schema describes all seven parameters in detail, so schema coverage is 100%. The description adds only the general 'Task text discarded' note and 'shape check' framing, which aligns with the per-parameter descriptions but adds no substantive meaning beyond them.

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

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

The description states a specific action ('Find a public pay-per-call tool gateway') and enumerates concrete returns (CLI setup, how-it-works, skill file, remote MCP hops). This distinguishes it from most siblings even though the term 'Monid' is unexplained.

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

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

No explicit when-to-use or when-not-to-use guidance is given, and no alternatives are referenced among the many sibling tools. The only signal is the verb 'Find', which implies a lookup use case but does not help an agent decide between this and related fetch/validate/index 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 disclosing side effects and behavior. It only states that no browser is launched, but it does not mention network requests, potential external calls, latency, failure modes, or any other behavioral consequences of checking a URL.

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 to the point, with no redundant fluff. The two sentences are easy to read and front-load the core purpose. However, the brevity comes at the cost of omitting necessary context about parameters and usage.

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

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

Given the mismatch between the description and the input schema, and the absence of an output schema or annotations, the description is not enough for an agent to understand what inputs are actually used, what results to expect, or how this tool fits into the broader toolset. Critical context is 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?

The input schema contains nine optional parameters, but most have descriptions that are irrelevant or contradictory to the stated purpose. For example, 'url' is described as 'HTTPS URL to normalize or cite' rather than to check, and fields like 'ref', 'city', 'feed', 'json', 'path', 'zone', and 'query' appear to be unrelated leftovers from other tools. This creates significant ambiguity about which parameters actually matter.

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

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

The description states a clear verb-resource pair ('check whether a URL can be opened') and adds a useful negative behavior ('No browser is launched'), which helps distinguish it from browser-based sibling tools. However, 'can be opened' is ambiguous—it could mean HTTP reachability, validity, or something else—and it does not name the specific sibling tools it contrasts with.

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 this tool should be chosen over alternatives like playwright-url-ok, fetch-status, or normalize-url. The only hint is the negative statement about not launching a browser, which is insufficient for an agent to decide when to invoke this tool.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure. It does disclose that the expression is discarded, which is a useful data-retention hint, but it does not say whether a result is returned, what side effects occur, or what 'discarded' means operationally. This is insufficient for a tool with no annotation safety 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?

The description is only two short sentences with no filler, and the main verb is front-loaded. The second sentence does communicate a behavioral trait, so it earns its place. It is concise and scannable, though its brevity contributes to the ambiguity.

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

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

Given no annotations, no output schema, and a mismatched input schema, the description leaves out critical operational information. An agent cannot determine how to supply the expression, what the tool returns, or when it should be selected. The 'discarded' note is a thin gesture toward completeness but does not resolve the core mystery.

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 individually documents its parameters well, so those entries would normally carry the semantic load. However, the description's core concept—an arithmetic expression—has no corresponding property in the schema, and the description adds no meaning to the listed parameters. An agent cannot tell which field, if any, should contain 'a' and 'b'.

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 ('Evaluate a+b style arithmetic'), which is more than a tautology, but the second sentence ('Expression discarded.') undermines the purpose by suggesting the input produces no result. The input schema contains no expression parameter at all, so the stated purpose does not match the actual invocation surface. Overall the intent is ambiguous and not clearly differentiated from the many sibling shape-check tools.

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

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

The description gives no guidance on when to use calc-eval versus alternatives like validate-json or domain-shape. There are no prerequisites, exclusions, or examples. The 'a+b style' phrase is the only contextual hint, but it is not actionable without an expression parameter.

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 does add a useful data-handling disclosure: 'Page content is not stored.' However, it does not state whether a network request is made, whether the operation is read-only, or how the many extra optional parameters are handled beyond the schema's own notes.

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 primary return value front-loaded and no filler. 'Page content is not stored' earns its place as a useful behavioral note, making this 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?

The tool has nine optional parameters, no output schema, and no annotations, so this one-line description is insufficient for reliable invocation. It does not explain how multiple parameters combine, what happens when no parameters are provided, or what output is returned for non-URL inputs such as json, city, or zone.

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

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

Schema description coverage is 100%, so the input schema already documents all nine parameters. The description adds no additional parameter semantics beyond highlighting URL, and it does not clarify how to choose among the many optional inputs such as city, feed, json, zone, or query.

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 ('Return host, scheme, and HTTP status') and a clear target ('for a URL'), so an agent can understand the basic purpose. It does not differentiate this tool from siblings like fetch-status or normalize-url, and the nine-parameter schema suggests a broader behavior than the description acknowledges.

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

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

There is no guidance about when to use this tool instead of alternatives such as fetch-status, normalize-url, or web-fetch. 'Page content is not stored' is a behavioral note, not a usage condition, so the description leaves selection criteria entirely to inference.

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

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

With no annotations, the description must carry behavioral disclosure on its own. It does add one useful privacy-related behavior ("No identifiers are retained"), which matters for a tool accepting refs, URLs, and paths. However, it omits other important behavioral details, such as whether any network access occurs, how the classification is computed, or what the return value represents.

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, but this is under-specification rather than effective conciseness. Two sentences carry only a vague purpose and a privacy note, leaving out nearly all information needed 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 is complex due to its seven unrelated-looking parameters and many shape/check/type siblings, yet there is no output schema and no annotation coverage. The description does not explain what classification is produced, which parameters are relevant when, or what output the agent should expect, so an agent cannot reliably select or invoke 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?

The input schema already provides descriptive explanations for every parameter, including discard behavior, so schema coverage is effectively 100%. The tool description adds no parameter-level meaning beyond the schema, which is acceptable because the schema 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 an action ("Show how this request is classified") but the classification scheme is never specified, so the purpose remains vague. It does not distinguish this tool from related siblings such as domain-shape, normalize-url, validate-json, or citation, and the word "compatibility" is never even used in the description.

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 any alternative. There are no conditions, exclusions, or references to sibling tools, and the description does not clarify which of the seven heterogeneous parameters a caller should provide or expect to matter.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only reveals that WHOIS/ownership data is not included; it does not describe output format, normalization behavior, side effects, error cases, or what happens with invalid hostnames. The schema field descriptions mention 'discarded' data, but the tool description itself is underspecified.

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: 'Split a hostname into labels without WHOIS or ownership data.' It front-loads the main action and resource, and 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 no annotations and no output schema, so the description should cover expected return values and invocation context. It does not explain what the split labels look like, whether all parameters are required or optional, or why several unrelated parameters appear in the schema. This is insufficient for an agent to confidently call the tool.

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

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

The input schema has descriptions for all seven parameters, so schema coverage is effectively 100%, giving a baseline of 3. The description adds no parameter-level meaning beyond what the schema already provides, nor does it reconcile why a domain-shape tool accepts city, feed, json, ref, or path 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 uses a specific verb and resource: 'Split a hostname into labels.' It also clearly distinguishes this from ownership/WHOIS lookups, and the 'domain-shape' name makes the target resource obvious relative to sibling shape tools. However, it does not explicitly name sibling alternatives or draw a contrast with them.

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

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

There is no guidance on when to use this tool over sibling shape tools such as figma-url-shape, github-repo-shape, or jira-key-shape. The phrase 'without WHOIS or ownership data' is a negative boundary, not a positive usage condition or an explicit exclusion with 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?

The description discloses the core behavioral traits: the HTTP method (HEAD), the target scope (public URLs), and the limited output (status only). It does not cover redirect handling or failure behavior, but for a simple network probe it provides enough behavioral transparency given no annotations exist.

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

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

The description is a single, front-loaded sentence with no filler. Every word earns its place: method, target, and output are all specified.

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

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

With nine optional parameters, no output schema, and no annotations, this one-sentence description is insufficient for reliable invocation. It does not state that `url` is semantically required, whether other parameters are ignored, or how the tool behaves when called without a URL; several parameter descriptions even suggest unrelated behaviors like JSON validation or weather hints.

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 coverage, but the `url` parameter description is misleading ('normalize or cite'). The tool description corrects this by identifying the URL as the HEAD target and clarifying that the result is a status only, adding meaning beyond the schema.

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

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

The description names a specific action (HEAD), a specific resource (a public URL), and a specific output (status only). This clearly distinguishes fetch-status from content-fetching siblings like web-fetch and from browser-based checks like browser-url-ok.

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

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

The phrase 'status only' gives clear context: use this when you need an HTTP status/probe rather than page content. However, it does not explicitly name alternatives or state when not to use it, so it falls short of the highest level.

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. The only disclosed trait is 'Path discarded,' which duplicates the schema's path parameter description ('discarded after the check'). The description does not reveal whether the tool fetches the URL, validates against Figma's URL format, or returns a boolean versus extracted components.

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 purpose front-loaded and zero fluff. However, the terseness borders on under-specification: 'Path discarded' is cryptic without context on what the path is discarded from or why, so the brevity saves words at the cost of clarity.

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

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

With no output schema and no annotations, the description must explain the tool's return value and behavior, but it only says 'Parse a Figma file URL.' The schema's nine unrelated parameters (city, feed, zone, query) appear copied from sibling tools and create confusion the description does not resolve. An agent cannot predict the output, validation semantics, or side effects.

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 documents every parameter. The description's 'Path discarded' adds slight tool-level disambiguation by implying the URL is the operative input among the odd grab-bag of 9 parameters, but it does not explain url format expectations or what 'parse' produces.

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

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

The description states a specific verb ('Parse') and resource ('a Figma file URL'), so an agent can tell what domain the tool targets. However, it never mentions the shape-checking behavior implied by the tool name and does not differentiate it from sibling URL tools like normalize-url or github-repo-shape.

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

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

There is no guidance on when to reach for this tool versus any of the 26 siblings. Given near-duplicate siblings such as browser-url-ok, playwright-url-ok, normalize-url, and various -shape tools, an agent has no basis to select figma-url-shape specifically. No when/when-not conditions or named alternatives appear.

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 does disclose the key trait that no disk access happens. It does not state the return value, error behavior, or what exactly counts as 'safe', leaving important expectations unspecified.

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

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

Two terse sentences with no filler, and the most important qualification, 'No disk access', is front-loaded immediately after the purpose. Every word earns its place.

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

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

The description and schema do not fully align: the tool claims to check path safety, yet the schema exposes eight unrelated optional fields, and there is no output schema or definition of 'safe'. An agent can infer a basic call, but the definition is incomplete for confident correct use.

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

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

Schema description coverage is 100%, so the baseline is 3; the tool description adds no parameter-level meaning beyond indicating that the checked resource is a path. The schema's many extra optional parameters such as url, city, zone, and query are individually documented, but their relationship to this tool is not explained.

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: checking whether a path looks safe, and adds that no disk access occurs. It distinguishes the tool from URL/domain/wiki validators, though 'looks safe' is left vague and the input schema exposes many unrelated optional 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?

'No disk access' implies this is a lightweight, side-effect-free preflight check, which is useful context. However, the description does not explicitly state when to prefer this over sibling tools such as browser-url-ok or domain-shape, nor does it give 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 must carry behavioral weight; it does disclose the core behavior and an external dependency on Open-Meteo. But it omits the response shape, side effects, and the fact that many schema fields appear irrelevant or 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 sentence with no filler and the key output is front-loaded. It is concise, though too terse to compensate for the ambiguous multi-parameter 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?

For a tool with 9 optional parameters, no annotations, and no output schema, the description is incomplete: it doesn't say which parameter to provide, what the returned data looks like, or whether the other schema fields are ignored. An agent cannot reliably invoke this tool correctly 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?

Schema coverage is 100%, so the baseline is 3. The description adds no parameter guidance, and the 9 optional fields are mostly unrelated to geocoding, leaving the agent to guess that 'city' is the relevant input.

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

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

The description states a clear purpose: returning latitude and longitude for a place via Open-Meteo. It is not a tautology and distinguishes the tool from many shape/URL-checking siblings, though it doesn't explicitly contrast it with weather-hint.

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

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

The intended use is implied: when an agent needs coordinates for a place, this tool provides them. However, there is no explicit guidance about when not to use it, which parameter identifies the place, or how it relates to similar lookup siblings.

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

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

With no annotations, the description carries the full burden. 'Parse' conveys a read-only, side-effect-free operation, which is appropriate for this tool. But it does not disclose invalid-URL behavior, output format, or whether the URL must be canonical, leaving edge cases 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 a single sentence with no filler and the core constraint is front-loaded. Every word earns its place.

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

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

There is no output schema and no annotations, so the description should at least specify the return shape and the parameter to use. Neither is explicit. With nine optional parameters and several sibling shape tools, more detail is needed for reliable invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds GitHub-specific meaning to the URL parameter (the schema only says 'HTTPS URL to normalize or cite'), but it does not explicitly identify `url` as the relevant parameter or explain the purpose of the eight other optional parameters.

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

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

The description names a specific verb ('parse'), a specific resource ('owner and repo'), and a specific input ('GitHub URL'), so an agent knows exactly what the tool does. It is also clearly distinct from sibling shape tools by being GitHub-specific.

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 is implied: use this when you have a GitHub URL and need owner/repo. However, it does not explicitly state when to prefer this over normalize-url, browser-url-ok, or other URL-related siblings, nor does it mention any exclusions.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It only discloses one trait ('Titles discarded') and does not clarify whether the tool performs network access, how current the snapshot is, whether it is read-only, or what the return shape is (just 'count'). This is a thin disclosure for a tool that appears to fetch live HN data.

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, and the core instruction is front-loaded before the discarded-title qualifier. Every word earns its place, making this the strongest 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?

The tool accepts nine optional parameters and has no output schema, so the description is responsible for clarifying how they relate to the operation and what the result looks like. It does neither: the parameters appear irrelevant to 'Count Hacker News stories', and the return (a number?) is only implied, leaving an agent to guess the relationship between the inputs and the 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?

Schema description coverage is 100%, so each parameter already has a textual description. At baseline, that warrants a 3. The tool description itself does not map its nine optional parameters to what it actually does—most seem unrelated to counting HN stories—so it adds no extra parameter meaning beyond the schema.

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

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

The description names a specific verb ('Count') and resource ('current Hacker News front-page stories') and adds a scope qualifier ('Titles discarded'), so an agent can grasp the core action. However, it does not distinguish this from sibling tools like memory-key-count or search-query-len, which also count items, so it misses the sibling-differentiation bar.

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, no prerequisites, and no exclusions. An agent that needs context like 'use this when you need a count of front-page stories but not their titles' would have to infer it entirely.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. The phrase 'for clock calls' weakly implies a read-only data resource, but the description does not state that it returns a list, what the output looks like, or whether the listed input parameters are ignored or discarded.

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

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

The description is a single short sentence with no wasteful words and the core subject is front-loaded. The lack of detail is a completeness problem rather than a conciseness or structure problem.

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

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

With no output schema, no annotations, and a seven-parameter input schema that appears unrelated to the stated purpose, the description is far too thin to let an agent invoke the tool correctly. It does not describe return values, side effects, or how any parameter influences the result.

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

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

All seven parameters have their own schema descriptions, so schema coverage is effectively 100% and the baseline is 3. The tool description adds no additional parameter meaning, and it fails to explain how ref, url, city, feed, host, json, or path relate to IANA timezone names.

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

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

The description identifies the resource (common IANA timezone names) and the intended domain (clock calls), but it uses a noun phrase rather than an explicit verb such as 'returns' or 'lists'. It also partially restates the tool name (iana-zones → IANA zones) and does not clearly distinguish it from sibling clock-related 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?

'For clock calls' signals the context in which the tool is meant to be used, which is useful guidance. However, it does not explicitly say when not to use it or mention alternatives such as timezone or utc-time, leaving the routing partially 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 provided, the description carries the full burden of behavioral disclosure. It only says it fetches and returns group counts; it does not mention failure behavior, redirects, rate limits, authentication needs, or whether the URL must point directly at a robots.txt. This is minimal disclosure for a network-fetching tool.

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

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

The description is one short sentence with no filler and is front-loaded with the main verb and resource. It is concise, though the conciseness comes at the cost of critical operational detail.

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

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

The tool has no annotations, no output schema, 9 parameters, and a one-line description. More importantly, there is a severe semantic mismatch between the tool's stated purpose and the parameter schema. An agent cannot determine the required input, expected output format, or edge cases from this 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 input schema has 9 parameters, none required, and their descriptions are entirely disconnected from the tool's stated purpose. For example, 'url' is described as 'HTTPS URL to normalize or cite' rather than as the robots.txt URL to fetch, and other parameters ('city', 'zone', 'query') appear unrelated. The description does not clarify which parameter should be supplied to fetch the robots.txt, leaving an agent unable to select the correct argument.

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

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

The description clearly states the action ('Fetch'), the resource ('a public robots.txt'), and the output shape ('return group counts only'). This is specific enough to distinguish it from generic web-fetching tools like web-fetch or fetch-status, though it does not explicitly name an alternative.

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

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

The description implies the tool should be used when someone needs group counts from a robots.txt file, but it gives no explicit guidance on when not to use it or which sibling tool to prefer. There are no stated exclusions or alternative-routing cues.

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 discloses one behavioral trait: 'Key discarded' implies the input key is not retained or returned. However, it does not mention the return format, error behavior, or whether the check is purely read-only beyond the natural meaning of 'check'.

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 and front-loaded: the action and object appear in the first sentence. 'Key discarded' adds a useful privacy hint without padding. It loses a point because the terseness contributes to the omission of critical 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?

Despite having a complex seven-property schema and no output schema, the description gives no indication of which parameter to pass, what the expected response is, or how failures are reported. It is not complete enough for an agent to reliably select and invoke the tool correctly.

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

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

The schema exposes seven string parameters (ref, url, city, feed, host, json, path), none of which is identified as the Jira key. The description never maps 'key' to any property, and the parameter descriptions appear unrelated to Jira issue keys. An agent cannot determine which field to populate, so the parameter semantics are severely underspecified and misleading for this tool's purpose.

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

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

The description names a specific verb ('Check') and a specific resource ('Jira issue key shape'), which distinguishes it from sibling shape tools like github-repo-shape or domain-shape. However, it does not state what the tool returns (e.g., boolean, normalized key), so it is not fully self-contained.

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 clearly enough: use when you need to validate a Jira issue key's shape. But there is no explicit guidance about when not to use it, what input type is required, or how it differs from related 'shape' tools beyond the resource name.

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

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

With no annotations, the description carries the disclosure burden. It usefully reveals that the body is discarded and only the HTTP status is relevant. It does not cover redirects, timeouts, error behavior, or access requirements, but it is not misleading.

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 function front-loaded and the key limitation stated immediately after. Every word earns its place; there is no filler or repetition.

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

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

With nine optional parameters, no output schema, and many sibling URL/status tools, this sparse description is incomplete. It does not say which parameter should be populated, what exact form the HTTP status takes, or how this tool differs from overlapping tools like fetch-status and browser-url-ok.

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

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

The schema already describes every parameter with 100% coverage, so the description does not need to repeat those details. It adds slight semantic refinement by implying the url parameter should be a public library docs URL, but it leaves the role of the other optional parameters to the schema.

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

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

The description states a concrete outcome: report the HTTP status for a public library docs URL, with the body discarded. This is a clear verb-plus-resource description and is more specific than a generic fetch tool, though it does not name any sibling to differentiate from.

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 context is implied by 'public library docs URL' — use this when you need only an HTTP status and not the response body. However, there is no explicit when-not-to-use guidance and no mention of alternatives such as fetch-status, browser-url-ok, or status-catalog.

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 of behavioral disclosure. It explicitly says 'Values discarded,' which is a meaningful behavioral trait, and the schema repeats 'discarded' language. However, it does not disclose return format, side effects, or how the JSON object is supplied.

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

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

The description is extremely concise: two short statements, front-loaded with the core operation. There is no filler, and the 'Values discarded' fragment earns its place as an important 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?

Given 9 optional parameters, no output schema, and no annotations, the description is too sparse for reliable invocation. It omits the return value, which parameter to use, and why unrelated-looking parameters exist, so an agent would need additional inference to use the tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3 and the description does not need to restate parameter details. It also does not add useful mapping between the 9 parameters and the 'JSON object' mentioned in the description, leaving ambiguity about which parameter should receive the object.

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

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

The description states a specific operation, 'Count keys in a JSON object,' and adds the useful qualifier that values are discarded. This differentiates it from siblings like validate-json, though the name 'memory-key-count' makes the description somewhat redundant.

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

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

There is no guidance on when to use this tool versus alternatives such as validate-json, search-query-len, or the other shape-check tools. The description only states what it does, not when it should be selected or when it should be avoided.

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

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

The description discloses the output behavior (dropping query/fragment) but does not mention whether it makes network requests, requires permissions, or has side effects. With no annotations, this is a moderate level of 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 two concise sentences immediately stating the core action and a key behavior. No redundant information 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?

While the description itself is clear, the input schema is filled with unrelated parameters, and the description does not address this mismatch or specify output format. The tool lacks necessary context for an agent to use it correctly without further information.

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 are present but largely irrelevant (ref, city, feed, json, zone, etc.) and do not match the tool's actual purpose. The description does not clarify that only 'url' is meaningful, leaving parameter semantics confusing.

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?

Description clearly states the tool returns origin, host, and path for a URL and explicitly notes that query and fragment are dropped. The verb 'return' and resource 'URL' are specific and unambiguous.

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

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

No guidance is given on when to use this tool instead of siblings. It does not mention alternatives like browser-url-ok or fetch-status, nor does it state conditions that would make this tool a better 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?

With no annotations present, the description carries the full burden of behavioral disclosure. It adds one useful trait—'No browser is launched'—but does not disclose whether network I/O occurs, whether the operation is read-only, what result is returned, or what 'discarded after the check' means in practice. This is insufficient for a tool with nine parameters and no schema-level safety hints.

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 compact and front-loaded: the action comes first, and the negative clarification 'No browser is launched' earns its place by countering the typical Playwright/browser assumption. It is not bloated, though it may be overly sparse for the tool's actual complexity.

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

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

Given nine optional parameters, no annotations, no output schema, and several close sibling tools, the description is too thin. It fails to explain return values, network behavior, parameter selection, or how this differs from browser-url-ok and fetch-status. The schema covers parameter names but not the tool-level context an agent needs to invoke it correctly.

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

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

Schema description coverage is 100%, so each parameter is already explained individually. The description adds no parameter-level meaning and its URL-focused framing could make an agent unsure whether city, feed, json, path, zone, and query are relevant to this tool. Still, the schema descriptions are detailed enough to carry the parametric semantics on their own.

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

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

The description states a clear verb and resource: 'Check whether a URL can be opened.' However, 'can be opened' is ambiguous—it could mean syntax validity, network reachability, or rendering—and the description does not distinguish this tool from siblings like browser-url-ok or fetch-status. The nine-parameter schema also includes city, json, zone, query, and other non-URL inputs, which the description does not account for.

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 browser-url-ok, fetch-status, normalize-url, or citation. The only hint is 'No browser is launched,' which implicitly rules out browser-rendering use cases but does not state when this tool is the right choice or which alternatives to prefer.

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. It discloses that the query is discarded, which is a useful side-effect guarantee (no retention). However, it does not mention what happens to the other optional parameters, any limits, or the nature of the return value, leaving most behavioral traits unstated.

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 primary purpose is front-loaded ('Count characters in a search query') and the secondary behavioral note ('Query discarded') is brief and essential. No words are wasted.

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 plus the schema are just sufficient for an agent to invoke the tool correctly: the 'query' parameter is explicitly tied to the length check. However, the description does not explain why eight other optional parameters exist, what the return value looks like, or how to handle multiple provided parameters, leaving notable ambiguity for an agent navigating the tool set.

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 thoroughly documents all nine parameters. The description adds no parameter-level detail beyond what the schema provides; it only aligns with the 'query' parameter by mentioning 'search query'. This matches the baseline of 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 states a specific action (count characters) on a specific resource (a search query), and 'Query discarded' adds a clear scoping detail. It does not, however, distinguish itself from sibling tools that also measure counts, nor does it explain why the schema includes eight other unrelated parameters, 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?

There is no guidance on when to use this tool versus alternatives. It does not mention conditions, prerequisites, exclusions, or any relationship to the many sibling tools. The only contextual hint comes from the schema's 'query' parameter description, not from the tool description itself.

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

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

With no annotations present, the description carries the full burden of explaining behavior, but 'Short catalog' reveals nothing about side effects, return values, error behavior, or what happens with inputs. The schema notes that many parameters are 'discarded', but the tool-level behavior remains completely 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 short and front-loaded, but it is under-specified rather than deliberately concise. One vague sentence does not earn its place because it fails to convey the tool's purpose or behavior despite the tool having a complex multi-parameter 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?

This is a tool with seven heterogeneous parameters, no output schema, and no annotations, yet the description only says it is a catalog of HTTP status codes. An agent cannot determine what to pass, what to expect back, or how this differs from related sibling tools, making the definition critically incomplete.

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

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

All seven parameters have individual descriptions in the schema, so schema coverage is essentially 100%. The tool description itself adds no parameter-level meaning, but the baseline of 3 applies because the structured schema already documents each field.

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

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

The description 'Short catalog of common HTTP status codes' merely restates what the tool name 'status-catalog' already implies, adding only 'common HTTP'. It lacks a specific verb or action, and with seven unrelated-looking parameters (url, city, feed, host, json, path) it is unclear what the tool actually does with them.

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

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

There is no guidance about when to use this tool versus siblings like fetch-status, normalize-url, or validate-json. The description gives no context, conditions, or exclusions, leaving the agent to guess when 'status-catalog' is the appropriate 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?

Because no annotations are present, the description carries the burden of explaining behavior. It does disclose one important behavioral fact, 'Prompt discarded', but it does not clarify whether all parameters are ignored, what side effects exist, or what the returned template looks like. The large parameter list with conflicting descriptions makes the tool's behavior more confusing rather than 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 short and avoids fluff, which is good. However, 'Prompt discarded.' is cryptic and the overall description is too minimal to carry the tool's unusual parameter surface. The brevity starts to sacrifice necessary context.

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

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

With no annotations, no output schema, and a long list of parameters that each claim different fates, the tool needs a more complete description to be usable. An agent selecting among many sibling tools needs to know when to call this tool, what the returned template contains, and why the parameters are present. The current description does not provide that.

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 gives rich descriptions for each parameter, so the baseline should be around 3, but the tool description does not connect them to the tool's purpose. It says 'Prompt discarded' even though there is no prompt parameter, and the schema descriptions suggest various processing actions such as 'normalize or cite' or 'validate', creating conflicting expectations. The description adds no parameter-level meaning beyond the schema and fails to clarify why these parameters exist.

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

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

The description names a concrete action and result: 'Return a three-step thinking template.' The extra sentence 'Prompt discarded' clarifies that the tool does not process the input, which is important for AI agents. It does not explicitly distinguish this tool from the sibling tools, but the function itself is specific.

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 rather than one of the many sibling tools, such as the shape, hint, or validation tools. 'Prompt discarded' implies it should not be used for actual reasoning, but no alternatives, prerequisites, or exclusion conditions 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 burden. It discloses only that the tool reports the current time, but not the return format, whether network access is required, or how invalid timezone names 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 a single compact sentence with no wasted words and the key idea front-loaded. However, its brevity leaves critical invocation details unaddressed.

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

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

With no annotations, no output schema, and an input schema that does not contain a timezone parameter, the description is far from complete. The missing link between the promised IANA-timezone input and the actual schema properties makes correct invocation impossible.

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

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

The description mentions a 'named IANA timezone,' but the input schema contains seven parameters—ref, url, city, feed, host, json, path—none of which is described as accepting an IANA timezone. An agent cannot determine which parameter to populate or how the timezone name should be supplied.

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: it returns the current time for a named IANA timezone. This also distinguishes it from utc-time, which would not require a named zone, though it does not explicitly call out that distinction.

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

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

There is no guidance about when to use this tool instead of alternatives such as iana-zones or utc-time. The intended usage is only implied by the phrase 'named IANA timezone,' with no exclusions or alternative routing.

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

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

With no annotations, the description must carry the full behavioral burden, but it only states the output. It does not disclose that the many input parameters are effectively ignored or that they do not affect the returned timestamp, leaving significant 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?

'Current UTC timestamp.' is extremely concise and front-loaded, with no wasted words. However, it is so brief that it omits important context about the input schema, making it concise at the cost of completeness.

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 a tool with 9 unrelated optional parameters and no output schema. It should explicitly state that parameters are accepted but ignored, and that the result is always the current UTC time, to prevent an agent from passing context-dependent arguments.

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

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

Schema description coverage is 100%, and individual parameter descriptions already document side effects such as 'discarded after the shape check' and 'no disk access.' The tool description adds nothing about parameters, but the schema carries that weight, so the baseline of 3 is appropriate.

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

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

The description clearly identifies the resource and result: 'Current UTC timestamp.' It is specific about UTC, which helps distinguish it from the 'timezone' sibling, but it lacks an explicit verb and does not acknowledge the unusual 9-parameter input schema.

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

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

No usage guidance is provided. The description does not say when to use this tool instead of siblings like 'timezone' or 'iana-zones', nor does it clarify that all parameters are optional and apparently ignored.

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 disclose one useful behavior ('The body is discarded'), but it does not clarify whether all other schema fields (url, city, feed, host, ref, path) are ignored, what the return value looks like, or whether any side effects 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 short and front-loads the core action, with no filler. It could be slightly improved by naming the 'json' parameter, but as-is it is efficient and easy to scan.

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

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

For a tool with seven parameters, no annotations, and no output schema, this description is too sparse. It does not explain how 'body' maps to the 'json' parameter, what the tool returns, why unrelated-looking fields exist, or how it should be used in 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 already documents all seven parameters with descriptions, so the description does not need to repeat parameter details. However, the description uses 'body' while the schema calls the relevant field 'json', which is a minor ambiguity; no parameter meaning is added 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 verb ('check') and a resource ('a body' as JSON), so the core purpose is clear and matches the tool name. It does not differentiate this validator from sibling validation tools like domain-shape or file-path-ok, but the basic purpose is unambiguous.

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

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

There is no guidance on when to use this tool versus the many sibling tools, nor any mention of exclusions or prerequisites. A sentence like 'Use this when you need to verify JSON syntax; for URL/hostname shape, use normalize-url/domain-shape' would be needed.

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

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

No annotations are present, so the description carries the full behavioral burden. It reveals that an external provider (Open-Meteo) is involved and implies a read-only temperature lookup, but does not mention units, return format, error behavior, rate limits, or any side effects.

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

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

The description is a single, front-loaded sentence with no filler. It is appropriately concise for a simple tool, though the brevity sacrifices useful behavioral and usage detail.

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

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

Given seven parameters, no annotations, and no output schema, the one-sentence description is incomplete. An agent is left unsure which parameter to populate, what the response looks like, whether other inputs are ignored, and how failures are surfaced.

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

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

All seven parameters already have descriptive schema text, including 'City name for a public weather hint', so baseline is 3. The description adds little beyond indicating that city is the relevant input, and does not clarify how to treat the other six parameters that appear in the schema.

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

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

The description states a specific resource ('current temperature for a city') and names the provider ('Open-Meteo'), which clearly conveys the tool's core function. It is reasonably distinct from siblings like geo-hint, though it does not explicitly call out the difference.

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 instead of alternatives, no exclusions, and no context for choosing weather-hint over related hint tools. The usage must be inferred entirely from the name and one-line purpose.

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 it does disclose a salient behavior: the HTTP body is discarded. It does not disclose whether any authorization or rate limits apply, how redirects/errors are handled, or what happens when non-URL parameters are passed; those gaps keep it from being stronger.

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 outcome first and the key limitation second; no filler. This is an appropriately sized, front-loaded description.

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 URL status check, the return value (HTTP status/content type) and the body-discarded behavior are enough to go on. But all nine parameters are optional, there is no output schema, and no annotations, and the description does not clarify how the non-URL parameters relate or whether at least one input is expected, so an agent could still be confused in edge cases.

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 each parameter; the description adds no parameter-level meaning. The description's 'public URL' aligns with the url parameter, but it does not elaborate beyond the schema.

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

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

The description names a concrete result (HTTP status and content type) and a clear resource (public URL), and adds that the body is discarded, distinguishing it from a generic fetch tool. It does not explicitly differentiate from siblings like fetch-status or browser-url-ok, and the schema's many non-URL parameters are not acknowledged, so it is clear but not fully scoped.

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?

'For a public URL' gives a context for use, and 'body discarded' is an implicit warning not to use it when content is needed. However, no when-not-to-use conditions or alternative tools are named, and the description does not address which of the nine optional parameters should actually be supplied.

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

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

Annotations already declare readOnlyHint, destructiveHint, and idempotenceHint. The description adds a non-obvious data-handling detail—the title is discarded after the call—which is not covered by annotations. However, it omits other behavioral context such as return value or error behavior, and the reference to a 'title' is inconsistent with a schema that has no title parameter.

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 tight—two short sentences with no filler. The core purpose is front-loaded and the discard note is relevant. It sacrifices necessary detail for brevity, but the conciseness itself is effective.

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 ten schema parameters and no output schema, a two-sentence description covering only the Wikipedia-title use case is inadequate. It fails to explain the role of the other parameters, what the output is, or how the tool behaves. The mismatch between the described 'title' and the actual parameter list leaves significant gaps 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 schema descriptions cover each property, but the tool description refers only to a 'Wikipedia title' that maps to none of the schema properties. This mismatch actively confuses parameter binding; an agent cannot tell whether the title is passed via url, ref, or another field. The description adds no clarifying semantic beyond the schema and introduces an ambiguous entity.

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 resource ('Wikipedia title') and clarifies the operation's effect ('Title discarded after the call'). It does not, however, differentiate this from sibling verification tools such as browser-url-ok or file-path-ok, which also check existence or validity.

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 context for when to choose this tool over alternatives. It neither states when a title-existence check is appropriate nor names any sibling tool for comparison. An agent cannot infer selection criteria beyond the narrow purpose.

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