Quoted-printable length, input discarded

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It only mentions that task text is discarded and that it returns connection methods. It doesn't disclose whether external calls are made, potential rate limits, auth requirements, or the exact nature of the returned methods. This is minimal and leaves important operational 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 concise sentences with no filler. The purpose is front-loaded and the key behavioral note (task text discarded) is included. It is appropriately sized for the tool's 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?

Despite having 9 optional parameters and no output schema or annotations, the description does not clarify how to construct a task (e.g., which parameter maps to which task type) or what the returned connection methods look like. It leaves critical details about input usage and output format unexplained, making it inadequate for an agent to invoke correctly without further inference.

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

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

Schema description coverage is 100%, so each parameter already has a description including 'discarded after the call' or similar. The main description adds the context that these parameters form a 'task' and that the tool finds a gateway, but this is marginal. Since the schema does the heavy lifting, a baseline of 3 is appropriate; the description doesn't materially enhance parameter understanding.

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

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

The description states a specific purpose: find a pay-per-call tool gateway for a task, and returns connection methods. It gives example tasks (weather, search, scrape, voice), making the intent clear. However, it doesn't explicitly contrast with sibling tools like weather-hint or search-query-len, though the meta nature is apparent.

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 does not provide any explicit guidance on when to use this tool versus the many sibling tools. It implies usage when a gateway is needed, but does not state when not to use it or name alternatives. An agent would have to infer which tool is appropriate based on the task.

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 only discloses that 'No browser is launched,' which is minimal. It fails to mention that most parameters are discarded after validation, how results are returned, or any error/edge-case behavior. With no annotations provided, the description carries the full burden but does not satisfy it.

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 (two sentences) but this is under-specification, not conciseness. It omits essential information about the tool's scope, parameters, and behavior, so it fails to serve its purpose despite being brief.

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

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

For a tool with 9 parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain why the extra parameters exist, what the tool returns, or how an agent should construct a call. The lack of any behavioral or parameter context makes the tool nearly unusable for correct selection and invocation.

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

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

Schema description coverage is 100%, so each parameter is documented in the schema. However, the tool description does not connect these parameters to the stated purpose; the parameter descriptions themselves (e.g., 'discarded after the shape check') suggest a broader shape-checking function that the main description contradicts. The description adds no value beyond the schema and actually creates confusion.

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

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

The description states a specific action ('Check whether a URL can be opened') but the input schema accepts nine unrelated parameters (ref, city, json, path, zone, query, etc.) that have nothing to do with URL checking. This mismatch makes the tool's actual purpose ambiguous and could mislead an agent into thinking it only handles URLs when it likely performs a broader shape-checking role.

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

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

No guidance is provided on when to use this tool vs. alternatives like normalize-url, fetch-status, or web-fetch. There is no mention of prerequisites, exclusions, or scenarios where a sibling tool would be more appropriate.

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

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

The only behavioral cue is 'Expression discarded,' implying no retention of the expression, but no annotations are provided to supplement this. There is no mention of side effects, input validation, or error behavior, which is insufficient for a tool with nine 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 extremely concise, using only two short sentences with no superfluous words or redundant information. It is well-structured for its brevity, though that brevity contributes to other deficiencies.

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

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

Given the tool has nine optional parameters, all with seemingly irrelevant descriptions, the description fails to provide any coherent context on how these parameters relate to arithmetic evaluation. The tool is effectively unusable as described, lacking essential instructions on parameter usage and expected output.

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

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

The schema descriptions are present but entirely mismatched with the tool's purpose (e.g., 'Git ref name,' 'HTTPS URL,' 'City name'). The description does not clarify which parameter holds the arithmetic expression, making it impossible to know how to construct a valid call. This is a critical gap.

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 evaluates 'a+b style arithmetic,' which is a specific action on a specific resource. However, it doesn't differentiate from sibling tools that might also handle numeric operations, and the parameter list is unrelated, creating confusion about the actual purpose.

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

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

No guidance is given on when to use this tool versus alternatives. It doesn't mention conditions, prerequisites, or scenarios where arithmetic evaluation is preferred over other operations, leaving the agent without context 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?

No annotations are provided, so the description carries the full burden. It discloses that page content is not stored, which is a useful negative guarantee, but it does not state whether the tool makes network requests, has side effects, or requires authentication. The schema hints that many parameters are discarded, but that is in the schema, not the description. Minimal behavioral disclosure beyond one fact.

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 concise, two sentences, with no fluff. The main action is front-loaded, and the additional note about not storing content is relevant. However, the brevity omits critical context, so it is efficient but not 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?

The tool has nine optional parameters, many of which seem unrelated to the described function (city, feed, json, path, zone, query). The description does not explain why these exist or how they relate to citation. There is no output schema, so the return format is unknown. The description is incomplete for an agent to call this tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-specific information; it does not mention any of the nine parameters or their roles. The schema descriptions are detailed, but the description does not synthesize them or explain which parameters are actually used for the core function.

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: return host, scheme, and HTTP status for a URL. However, it does not differentiate from sibling tools like fetch-status or web-fetch, and the tool name 'citation' suggests a different purpose. The action is clear but the distinctive purpose is not.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, conditions, or comparisons to sibling tools. An agent would have to infer usage from the name and description.

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

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

No annotations are provided, so the description carries the full burden of disclosing side effects and privacy. The only disclosure is 'No identifiers are retained', which addresses data retention but says nothing about read-only status, external calls, error behavior, or output format. This is minimal coverage for a tool with 9 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 only two sentences, which is concise, but it omits essential information such as what the tool actually does with the inputs. This is under-specification, not efficient conciseness; the tool needs more explanation to be usable.

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

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

With 9 parameters, no output schema, and no annotations, the description must provide substantial guidance, but it only offers a vague statement about classification and a privacy note. The agent has no idea what to expect from the output, how the parameters interact, or what 'classification' entails. This is completely inadequate for a tool of this complexity.

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

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

Schema description coverage is 100%, so each parameter is documented in the schema with notes like 'discarded after the shape check'. The description itself adds no extra meaning beyond the schema, so the baseline score 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 says 'Show how this request is classified' but does not specify what classification means, what resource is being classified, or what the output looks like. The tool name 'compatibility' is also vague and does not clarify the purpose. It fails to distinguish itself from many specific sibling tools like 'domain-shape' or 'validate-json'.

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

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

No guidance is provided on when to use this tool versus the many alternatives. There is no mention of conditions, prerequisites, or exclusions, leaving the agent to guess which of the 9 parameters is relevant for a given scenario.

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 full burden of behavioral disclosure. It only states that the tool splits a hostname into labels, but does not describe the output format (e.g., array of strings, object), error handling, or which of the multiple input parameters is actually used. The presence of many seemingly unrelated parameters (ref, city, json, etc.) without explanation adds confusion about the tool's real 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, compact sentence that contains no filler or redundant wording. It efficiently encapsulates the tool's core function and a key limitation. The structure is ideal for a tool 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?

Given the absence of an output schema and the ambiguity around input parameters, the description is incomplete. An agent cannot determine which parameter to pass or what the result will look like. The tool is simple, but the description lacks essential context about input and output expectations, making it insufficient 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 schemas' parameter descriptions are generic and not tailored to this tool—e.g., 'host' is described as 'Public hostname', which is vague, and other parameters like 'ref' or 'city' appear arbitrary. The tool description does not clarify which parameter is relevant for the splitting operation, nor does it add meaning to the parameters. With 9 parameters and no guidance on their roles, the description fails to provide semantic clarity beyond the already present (and confusing) schema descriptions.

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: 'Split a hostname into labels'. This is specific and unambiguous, and the clause 'without WHOIS or ownership data' distinguishes it from tools that provide richer domain information. The purpose is immediately understandable.

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

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

The description implies usage for splitting hostnames, but does not explicitly state when to prefer this tool over related tools like 'normalize-url' or 'browser-url-ok'. The phrase 'without WHOIS or ownership data' hints at what it does not do, but no direct alternative is named. Guidance is implicit rather than explicit.

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

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

With no annotations, the description must disclose behavior, but it only says 'HEAD a public URL and return status only,' implying no content retrieval. It does not mention side effects, authentication, or that most parameters are discarded (as hinted in the schema), leaving agents unaware of the tool's actual 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, front-loaded sentence with zero redundancy. It is maximally concise, though this brevity contributes to its incompleteness.

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

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

For a tool with 9 parameters and no output schema, this description is severely incomplete. It does not explain the purpose of the non-URL parameters, the meaning of 'status', or the return format. The schema descriptions partially compensate, but the tool description fails to tie everything together.

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 baseline is 3. The description adds no parameter-specific meaning, and it does not clarify how parameters like 'city' or 'json' relate to the HEAD operation, but it does not contradict the schema either.

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 (HEAD) and resource (public URL) but only mentions a single use case. The schema exposes nine parameters (city, json, zone, etc.) that are not referenced, making the actual scope ambiguous. It may be a multi-purpose status checker, but the description does not unify these elements.

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

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

No guidance is given on when to use this tool versus siblings like web-fetch, browser-url-ok, or normalize-url. There are no exclusions or conditions that would help an agent select this tool appropriately.

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 explicitly states that the path is discarded, which is useful, but it says nothing about side effects, return format, or the behavior of the many other parameters. The description is partially transparent but incomplete for a tool with 9 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 extremely concise at one sentence, with no fluff or redundancy. It front-loads the primary purpose. However, the brevity comes at the cost of omitting essential information, so while it is efficient, it is under-specified for the tool's complexity.

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

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

For a tool with 9 parameters, no output schema, and no annotations, the description is severely inadequate. It fails to explain the purpose of the unrelated parameters, return values, or when to use the tool. The description covers only a fraction of the tool's apparent functionality, leaving the agent with insufficient context to call 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 documented in the schema. The description adds minimal value by implying the 'url' parameter is the focus, but it does not explain the role of the other 8 parameters or how they interact. It neither compensates for schema gaps nor adds significant meaning.

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

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

The description clearly states the tool parses a Figma file URL and discards the path, which is specific and distinguishes it from sibling shape tools like domain-shape or jira-key-shape. However, the schema includes many unrelated parameters (city, feed, json, etc.) that are not explained by the description, creating ambiguity about the tool's actual scope.

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

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

The description provides no guidance on when to use this tool versus alternatives such as normalize-url, browser-url-ok, or other shape validators. It neither states when not to use it nor compares it to siblings, leaving the agent to infer 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 carries the full burden of behavioral disclosure. It states 'No disk access,' which is a useful non-destructive guarantee, but it does not specify what constitutes 'safe' or what happens on invalid input (e.g., error vs. boolean return). The single behavioral hint is insufficient for a tool that may validate diverse parameter types.

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 fluff, and the core action plus a key behavioral note are front-loaded. It is appropriately concise for a simple check, though the brevity leaves out essential context, so it is not perfect but still efficient.

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

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

For a tool with 9 optional parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain how the tool handles parameters other than 'path', what a 'safe' path means, what the return value indicates, or any failure modes. An agent cannot fully understand the tool's behavior 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?

Schema description coverage is 100%, so each parameter has a basic description in the schema. However, the tool description adds no extra meaning about how parameters are used; it only mentions 'path' and does not clarify how 'safe' applies to other parameters like 'url' or 'json'. The description offers little value beyond the schema for parameter understanding.

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

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

The description states a verb and resource ('Check whether a path looks safe'), but 'safe' is ambiguous—could mean syntactic validity, security risk, or existence. It does not distinguish from siblings like browser-url-ok, and the schema contains 9 unrelated parameters (url, city, feed, etc.) yet the description only references 'path', creating a mismatch that confuses the tool's actual scope.

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

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

The description offers no guidance on when to use this tool versus alternatives. It does not mention prerequisites, conditions, or contrast with sibling tools such as browser-url-ok or figma-url-shape. An agent cannot infer whether this is for files only or also for URLs, nor when to prefer it over other check tools.

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

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

With no annotations provided, the description carries the full burden of explaining behavior. It does not mention network usage, side effects, or the fact that many parameters appear to be discarded or unused, so the actual call behavior remains 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 very short and free of unnecessary words. It conveys the core purpose in a single sentence, though it could be more informative without becoming verbose.

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

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

The tool has nine optional parameters and no output schema, but the description does not explain expected return format or which parameter should be used for the place. This leaves substantial ambiguity for an agent attempting to invoke the tool correctly.

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

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

The description does not map 'place' to any specific parameter. Although the schema has a 'city' parameter and 100% coverage, the tool description itself adds no parameter meaning, and the schema descriptions for other parameters are largely unrelated to geolocation.

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

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

The description clearly states that the tool returns latitude and longitude for a place using Open-Meteo. It distinguishes this tool from siblings like weather-hint or timezone, though it does not specify which input parameter represents the place.

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

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

No guidance is provided about when to use this tool versus alternatives. There is no mention of when geo-hint should be preferred over weather-hint or other sibling tools, leaving the selection criteria implicit at best.

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 does not disclose side effects, read-only behavior, or what happens to other inputs. The schema hints that some parameters are 'discarded', but the description remains silent, leaving behavior unclear.

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 is easy to read. However, the overall tool specification is not concise due to the unwieldy schema with many unrelated fields.

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

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

The description lacks essential context: it does not explain what is returned, why other parameters exist, or how they relate to the stated purpose. Without an output schema or further explanation, the tool is incompletely specified.

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

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

Although the schema has 100% description coverage, many parameter descriptions (e.g., city, zone, query) are irrelevant to parsing a GitHub URL. The 'url' parameter is present but the rest are extraneous, and the description does not explain their purpose, leading to confusion.

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

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

The description clearly states a specific action (parse owner and repo) and a specific resource (GitHub URL). However, the schema includes many unrelated parameters, which may confuse an agent about the actual scope, though the description itself 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?

The description provides no guidance on when to use this tool versus alternatives, nor any conditions or prerequisites. It simply states the action without context or comparison to 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 of behavioral disclosure. It only mentions that titles are discarded, but does not state whether the tool makes network calls, returns a count, or has any side effects. It also does not explain why the schema includes 9 optional parameters that seem unrelated to the stated 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 concise at two sentences, but it is under-specified. It front-loads the core purpose but omits essential details about parameters and behavior. Conciseness is achieved at the expense 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?

For a tool with 9 optional parameters, no output schema, and no annotations, the description is severely incomplete. It fails to explain what the tool returns, what the parameters do, or whether it performs network I/O. An agent cannot reliably invoke this tool correctly based on the description alone.

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

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

Schema description coverage is 100%, so the schema already documents each parameter individually. However, the tool description adds nothing about how these parameters relate to the counting action. The description does not mention that parameters are optional or that they are ignored, leaving agents without clarity on whether arguments affect the result.

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

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

The description states a clear purpose: 'Count current Hacker News front-page stories.' This is a specific verb and resource, distinguishing it from siblings like 'web-fetch' or 'fetch-status'. However, it does not mention the many parameters in the schema, which could confuse an agent about what arguments are relevant.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any conditions, exclusions, or scenarios where other tools like 'web-fetch' would be preferred. An agent receives no context about appropriate usage.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not mention side effects, data persistence, or the role of the many parameters. Some schema descriptions say 'discarded' but the tool description offers no overview of 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 short but not effectively concise; it under-specifies the tool. Every sentence should add value, and this single sentence is too vague to be useful.

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

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

With 9 parameters, no output schema, and no annotations, the description is completely inadequate. An agent cannot determine what the tool does, what it returns, or how to pass parameters. This is far below the minimum viable level.

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%, but the description adds no meaning beyond the schema. The parameters (ref, url, city, feed, host, json, path, zone, query) are diverse and unrelated to timezone names; the description does not explain how they relate to the tool's purpose, leaving the agent confused about which to supply.

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 'Common IANA timezone names for clock calls' hints at a list or lookup of timezone names but lacks a clear verb and resource. It does not state whether the tool returns, validates, or filters names, and it does not differentiate itself from sibling tools like 'timezone' or 'utc-time'.

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

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

There is no guidance on when to use this tool versus alternatives. The phrase 'for clock calls' is vague and does not explain the conditions under which an agent should invoke it or when to prefer a sibling tool.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It claims to fetch robots.txt but omits that most parameters are discarded after validation (per schema descriptions), that network access is involved, or how group counts are derived. The actual multi-purpose behavior is hidden.

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, brief sentence, which is concise, but it under-specifies a tool with 9 parameters and a generic shape-checking role. Conciseness here sacrifices essential context, making it less useful than a slightly longer but accurate 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?

Given the high parameter count, no output schema, and no annotations, the description is grossly incomplete. It doesn't explain the 'group counts' result, how the tool handles the various inputs, or what distinguishes it from other shape checkers. The agent cannot reliably invoke it.

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

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

Although schema description coverage is 100%, the description adds no parameter-level meaning and even contradicts the schema by singling out robots.txt while most parameters (city, feed, json, path, zone, query) are unrelated. It fails to clarify which parameters apply to the stated purpose.

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

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

The description states a specific action ('Fetch a public robots.txt and return group counts only'), but the input schema exposes 9 unrelated parameters (city, feed, json, path, zone, query) that are described as shape-check candidates, not robots.txt inputs. This mismatch makes the tool's actual purpose unclear and fails to differentiate it from sibling shape-checkers like domain-shape or 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?

No guidance is given on when to use this tool versus alternatives. The description mentions only robots.txt, yet the schema implies a broader shape-checking role, leaving the agent without a clear selection rule. It neither states exclusions nor names sibling 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 one behavioral trait: 'Key discarded.' This indicates the key input is not retained. With no annotations provided, the description carries the full burden, but it says nothing about side effects, permissions, return values, or whether the tool is read-only. The single behavioral note is insufficient for a tool with such a broad 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 short—two sentences totaling ten words. It is concise but under-specified, omitting critical information such as which parameter to use. While brevity is positive, it sacrifices the minimal information needed to operate the tool effectively.

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 parameters, no output schema, and no annotations, the description is grossly incomplete. It does not explain what the 'shape check' entails, what the result looks like, how to select the appropriate parameter, or any constraints. The mismatch between the described purpose and the schema makes it nearly impossible for an agent to use 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 description does not map its stated purpose to any of the nine parameters. It never identifies which parameter represents the Jira key, and the schema descriptions (e.g., 'Git ref name', 'HTTPS URL', 'City name') are unrelated to Jira. Even though schema coverage is 100%, the description adds no clarity on how to invoke the tool for its intended purpose, leaving the agent confused.

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

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

The description states a specific verb and resource: 'Check a Jira issue key shape.' This clearly distinguishes it from siblings like 'github-repo-shape' or 'domain-shape'. However, the input schema does not include any parameter explicitly labeled as a Jira key, creating a mismatch between the stated purpose and the actual parameters an agent must provide.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention any conditions, exclusions, or sibling tools. An agent is left to infer that it should be used for Jira key shape validation, but no explicit routing advice is given.

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

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

The only behavioral note is 'Body discarded,' implying only the status code matters. However, it does not disclose whether the URL is fetched, any side effects, rate limits, or what the response contains. With no annotations, the description carries the full burden and falls short.

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 concise and front-loaded with the main action, but it is under-specified. A single sentence with a useful clause ('Body discarded') is efficient, yet it omits critical context, making it more an under-specification than a well-structured summary.

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

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

With 9 parameters, no output schema, and no annotations, the description is grossly incomplete. It fails to explain what the tool does with each parameter, what the response looks like, or any prerequisites. The mismatch between the description and the schema makes the tool nearly unusable without external knowledge.

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%, the tool description does not clarify how the parameters relate to the stated purpose. It mentions 'public library docs URL' but the schema includes city, feed, json, path, zone, etc., which are unexplained in context. The description adds no meaning beyond the schema and even creates confusion.

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

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

The description states a clear verb ('HTTP status') and a resource ('public library docs URL'), but the resource is oddly specific and does not align with the 9 unrelated parameters in the schema. It does not differentiate from siblings like fetch-status or browser-url-ok, which likely serve similar purposes.

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

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

No guidance is given on when to use this tool versus alternatives. The description does not mention conditions, exclusions, or point to any sibling tool for similar tasks, leaving the agent to guess based on the 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?

The description discloses that values are discarded, which is a behavioral trait, but with no annotations the burden is higher. It fails to disclose how the JSON object is provided (e.g., via the 'json' parameter) or any side effects, making the behavior under-specified.

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 ('Count keys in a JSON object. Values discarded.'), which is concise but under-specified. It front-loads the core action but omits necessary operational 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?

With 9 optional parameters, no output schema, and no annotations, the description is grossly inadequate. It doesn't explain how to invoke the tool, which parameter to use, or what the return value (the count) looks like. The schema's unrelated parameters compound the confusion.

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% with each parameter having a description, so the baseline is 3. The tool description adds no parameter meaning beyond the schema; it doesn't clarify which parameter is relevant to the key-counting purpose.

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

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

The description states a specific verb+resource ('Count keys in a JSON object') which is clear and distinct from sibling tools. However, it doesn't indicate which parameter holds the JSON object, leaving a mapping ambiguity that slightly reduces clarity.

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

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

No guidance on when to use this tool vs alternatives like validate-json or domain-shape. The description provides no context or exclusions.

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

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

The description discloses a key behavior—'Query and fragment are dropped'—which is helpful. However, with no annotations provided, it does not explain the behavior of the other eight parameters (e.g., ref, city, feed), which appear in the schema but are not mentioned in the description. This leaves uncertainty about whether they are used or ignored, reducing 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, clear sentence that front-loads the main purpose and includes the key behavioral note about dropping query and fragment. There is no wasted wording, and it is appropriately concise for the stated operation.

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 and no required fields, yet the description only addresses URL normalization. It does not explain how to invoke the tool correctly (e.g., which parameter to use) or what happens when other parameters are passed. The absence of an output schema means the description should describe the return structure, but it only mentions 'origin, host, and path' without format. This is incomplete for an agent to use reliably.

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

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

The input schema has 100% description coverage, so every parameter is already documented with its purpose (e.g., 'url: HTTPS URL to normalize or cite'). The tool description adds minimal value beyond stating the output; it does not clarify how parameters map to the URL normalization logic or which parameter is primary. With high schema coverage, a baseline of 3 is appropriate.

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

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

The description states a clear verb and resource: 'Return origin, host, and path for a URL.' This is specific and immediately understandable. However, it does not differentiate from sibling tools like domain-shape or github-repo-shape, which also handle URL-related shapes, so it lacks explicit 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?

The description provides no guidance on when to use this tool versus alternatives. It does not mention any sibling tools or conditions for selecting normalize-url over domain-shape, github-repo-shape, or similar. An agent is left to infer usage solely from the description.

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

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

With no annotations provided, the description carries the full burden. It discloses one behavioral trait: no browser is launched. However, it does not explain what 'check whether a URL can be opened' actually entails—does it make an HTTP request, validate syntax, or return a boolean? It also does not clarify the behavior for the many extraneous parameters, which appear to be discarded but are not explained. This leaves major 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 concise, one sentence, which is appropriately sized for a simple tool. However, it is under-specified: it omits critical details about the return value, the meaning of the many parameters, and usage context. The brevity is not a strength because it fails to convey the necessary information, so it sits at a 3 rather than higher.

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

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

Given the tool has 9 parameters, no output schema, and no annotations, the description is severely incomplete. It only covers the URL check aspect, leaving the other parameters unexplained. There is no information about what the tool returns, how it handles errors, or when to use it. For a tool with this complexity, the description provides almost no context, making it inadequate for an agent to use 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 has 100% description coverage, so the baseline is 3, but the parameter descriptions themselves are confusing and not tied to the tool's stated purpose. For example, 'ref' is described as 'Git ref name; discarded after the shape check,' and 'city' is 'City name for a public weather hint; discarded after the call.' These suggest the tool performs other checks, but the description only mentions URL checking. The parameter descriptions add little value because they don't explain how they relate to the core function, and the tool description does not compensate for this misalignment.

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: 'Check whether a URL can be opened' and adds a key distinction: 'No browser is launched.' This gives a specific verb and resource. However, the input schema lists 9 unrelated parameters (city, feed, json, path, zone, etc.) with no explanation in the description, creating ambiguity about the tool's actual scope. The purpose is clear for the URL check but the schema suggests it might handle other checks, which is not addressed.

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

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

No guidance is provided on when to use this tool versus alternatives. The description only states the basic function and the fact that no browser is launched, which hints at a lightweight alternative to browser-url-ok, but it never explicitly mentions sibling tools or selection criteria. There is no exclusion of cases where a browser is required or where other tools like fetch-status or normalize-url would be more appropriate.

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, and the description does not disclose any side effects, return values, or behavior beyond 'input discarded.' The tool's actual function (e.g., returning a length) is not revealed, leaving the agent to guess.

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

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

The description is extremely short, but its brevity is not helpful. It omits essential information about the tool's purpose and behavior, making the conciseness counterproductive. A more informative one-sentence summary would be preferable.

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 explanation of return values, and ambiguous parameter roles, the description leaves the agent without enough context to determine what inputs to provide or what to expect. The tool appears to accept any combination of optional parameters but gives no clue about the actual computation.

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

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

Although the schema covers all 9 parameters with descriptions, each description merely states that the parameter is 'discarded after' a generic action (e.g., 'shape check', 'length check'). These descriptions do not explain what the parameter is used for or how it affects the tool's behavior, adding no meaningful semantics beyond the parameter 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 'Quoted-printable length, input discarded' is cryptic and does not state what the tool actually does. It lacks a clear verb or resource, and the meaning of 'quoted-printable length' is ambiguous without further context.

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

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

No guidance is provided on when to use this tool versus alternatives. The description offers no context for selection, and sibling tools with clearer purposes (e.g., search-query-len, validate-json) are not referenced or differentiated.

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

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

With no annotations, the description carries the full burden. It states 'Query discarded' but does not disclose that other parameters (ref, url, city, etc.) are also accepted and discarded, nor that the tool likely performs shape checks on them. This omission could mislead the agent about the tool's actual 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 very short (two sentences) and front-loaded with the primary action, which is good. However, it omits critical context about the schema's other parameters, making it under-specified rather than 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?

Given 9 optional parameters, no required fields, no output schema, and no annotations, the description is incomplete. It does not explain the purpose of the additional parameters, what the tool returns, or how it handles multiple inputs. An agent would be uncertain whether to pass only 'query' or also other fields.

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 100% of parameters, so the schema already documents each field. The tool description adds no meaning beyond the schema, and it fails to clarify why unrelated parameters exist when the stated purpose is only query length. Baseline 3 applies because the schema is sufficient, but the description does not enhance understanding.

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 ('Count characters in a search query'), but it is ambiguous given the schema lists 8 other parameters (ref, url, city, etc.) with no explanation of how they relate to the stated purpose. It does not distinguish itself from siblings like 'hn-front-count' or 'think-steps'.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention any conditions, exclusions, or related tools, leaving the agent to infer usage from the 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?

There are no annotations and no description of side effects, permissions, or read-only guarantees. Even the tool's output format or potential for errors is unmentioned, offering no transparency about runtime 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 short sentence with no unnecessary words, achieving high conciseness. However, the brevity sacrifices clarity about the tool's function.

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 usage context, and parameter descriptions that do not match the tool's purpose, the description is severely incomplete. An agent would have no idea what to pass or what to expect in response.

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

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

The nine parameters have generic descriptions that are entirely unrelated to HTTP status codes (e.g., 'Git ref name,' 'City name,' 'Search text'). These descriptions appear copied from other tools and do not clarify how they relate to the catalog, making them misleading rather than informative.

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 the tool is a 'Short catalog of common HTTP status codes,' which clearly identifies the subject matter but does not specify what action the tool performs (e.g., returns, lists, retrieves). It is a noun phrase rather than a verb phrase, leaving some ambiguity.

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

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

No guidance is provided on when to use this tool versus the many sibling tools (e.g., fetch-status, normalize-url). The description gives no indication of appropriate use cases or contextual triggers.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose that the prompt is discarded, but the parameters are not prompts, and the tool's actual behavior (returning a fixed template) is not explained. The descriptions of each parameter in the schema mention that they are 'discarded after the shape check,' which hints at some internal checks, but the description itself does not clarify what side effects or return values to expect.

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, consisting of two short sentences. The main purpose is front-loaded. However, the second sentence is cryptic and does not add clarity, and the overall brevity borders on under-specification rather than efficient communication.

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

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

For a tool with 9 parameters and no output schema, this description is severely incomplete. It fails to explain what the three-step thinking template is, how it is structured, how the parameters relate to it, or what the agent should expect as a result. The absence of any behavioral detail makes it impossible for an agent to call this tool correctly and interpret the output.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no additional meaning beyond the schema; each parameter's schema description already states it is discarded after a check. The tool description's 'Prompt discarded' does not map to any parameter and does not enrich understanding of the parameters' roles.

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 'Return a three-step thinking template' which gives a verb and resource, but it is vague about what the template is or how it is used. The phrase 'Prompt discarded' is confusing because there is no 'prompt' parameter in the schema, and it does not distinguish this tool from the many sibling tools that perform specific checks.

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 alternatives. The description provides no context about the intended use case, prerequisites, or conditions that would select this tool over siblings like 'domain-shape' or 'validate-json'.

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

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

With no annotations, the description carries the full burden of disclosing behavior. It implies a read-only time lookup, but it does not mention that most schema parameters are unrelated or ignored, nor does it state any side effects or output 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 one-sentence description is concise, front-loaded, and free of filler. It states the essential purpose immediately without unnecessary 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 nine optional parameters, no output schema, and no annotations, the description is too sparse. It does not specify which parameter to use, what happens when no zone is supplied, what the return format is, or why the other parameters exist.

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 met, but the description adds no parameter-level meaning. The schema lists nine optional strings, many with descriptions like 'discarded after the shape check' or 'no disk access,' which are confusing for a timezone tool; only 'zone' is clearly relevant.

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

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

The description 'Current time in a named IANA timezone' clearly states the tool's core function and distinguishes it from sibling tools like utc-time and iana-zones. It does not explicitly name those alternatives, but the intended 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 about when to choose this tool over alternatives, what inputs are expected, or what to do when the relevant parameter is omitted. The description provides only the core function and no usage context.

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

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

With no annotations, the description carries full responsibility for explaining behavior. It only states the output (UTC timestamp) but does not mention that the nine input parameters are effectively ignored (despite having descriptive schema texts). An agent might incorrectly assume parameters influence the result.

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

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

The description is a single, compact sentence with no fluff or redundancy. It is perfectly sized for the simple function it describes.

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

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

The description is too sparse given the unusual presence of nine seemingly irrelevant parameters. It does not explain why these parameters exist or how they relate to the timestamp function, leaving a significant contextual gap. There is also no mention of the output format or type.

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

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

The schema descriptions cover all parameters and explicitly note they are 'discarded' or used only for validation. Since schema coverage is 100%, the description does not need to add extra detail. The baseline of 3 applies because the schema already handles parameter semantics adequately.

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 core function—returning the current UTC timestamp. It is specific and unambiguous, though it does not explicitly contrast with sibling tools like timezone or iana-zones, which is a minor gap.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of typical use cases, limitations, or scenarios where another tool would be more appropriate.

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 says the body is discarded and the path parameter says 'no disk access', but it does not clarify the overall side-effect profile beyond that. With no annotations, the description bears the full burden of disclosing behaviors; it fails to explain whether network, storage, or external systems are touched.

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, but its brevity comes at the cost of clarity and completeness. It is front-loaded with a clear verb, yet the second sentence introduces the unexplained 'body' concept that conflicts with the provided parameters.

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, no mention of success or failure behavior, no required parameters, and no explanation of edge cases like malformed JSON. The tool is not sufficiently specified for an agent to call it confidently or interpret its 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?

Although schema coverage is 100%, most parameter descriptions are semantically unrelated to JSON validation (e.g., 'Git ref name', 'IANA timezone name', 'Search text'). Only the 'json' parameter directly relates to the stated purpose, so the parameter meanings are largely confusing or misleading.

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

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

The description states a clear action ('Check whether a body is valid JSON'), but the input schema contains no 'body' parameter and instead lists many unrelated fields such as ref, url, city, zone, and query. This mismatch makes the actual purpose ambiguous.

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

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

No guidance is given for when to use this tool versus the many sibling validation tools like file-path-ok, browser-url-ok, domain-shape, or search-query-len. The description does not mention exclusions, prerequisites, or alternative 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 carries the full burden of explaining side effects, network I/O, failure modes, or read-only behavior. It only mentions the data source (Open-Meteo) and does not disclose whether the tool makes external calls or what can go wrong.

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 main tool description is concise and direct. However, the parameter descriptions are repetitive boilerplate ('discarded after...') and include many irrelevant fields, which bloat the schema and reduce overall structural quality.

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

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

There is no output schema, and the description does not specify the return format (e.g., units, whether conditions are included) or error behavior. With 9 optional parameters, the tool's actual invocation requirements and expected results remain unclear.

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

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

Although every parameter has a description, most are irrelevant to the stated purpose (e.g., 'ref', 'url', 'feed', 'host', 'json', 'path', 'query'). The 'city' parameter is clearly relevant, but the repetitive 'discarded after...' phrasing adds confusion rather than clarity.

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

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

The description clearly states that the tool provides the current temperature for a city via Open-Meteo. This distinguishes it from sibling tools like geo-hint or web-fetch, though it lacks an explicit verb such as 'get' or 'retrieve'.

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, nor does it mention prerequisites or limitations. It simply states the function without contextual usage direction.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that the body is discarded, which is useful, but it does not explain what happens with the many other parameters in the schema (city, feed, json, etc.). The description focuses only on URL, yet the schema suggests a broader purpose, creating ambiguity. There is no mention of rate limits, auth, or error behavior. This is a significant gap.

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

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

The description is a single sentence with no wasted words. It front-loads the core purpose and includes a key behavioral detail (body discarded). It is appropriately concise and easy to parse.

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

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

Given the tool has 9 parameters and no output schema, the description is incomplete. It only addresses the URL use case and does not explain the purpose of the other parameters (city, feed, json, etc.), which are not obviously related to HTTP status checks. An agent cannot understand the full scope of the tool or when it would be appropriate to use it with non-URL inputs. The lack of output schema also means the description should clarify what is returned, but it only vaguely mentions 'status and content type' without detail.

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 input schema already documents all 9 parameters. The tool description adds no parameter-specific information beyond what the schema provides. Per the rubric, baseline is 3 for high coverage, and the description does not improve or complement it. It neither clarifies relationships between parameters nor adds usage context.

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

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

The description states a specific verb (fetch) and resource (public URL) with a clear scope: 'HTTP status and content type'. It also distinguishes itself from siblings by noting 'Body discarded', which differentiates it from tools like fetch-status that might return more. This is not a tautology and provides clear purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives like fetch-status, normalize-url, or browser-url-ok. It does not mention conditions, exclusions, or any selection criteria. The context is implied but no explicit direction is given, leaving the agent to infer usage.

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

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

With no annotations provided, the description carries the transparency burden. It discloses that the title is discarded and the operation is only an existence check, implying a read-only, non-persistent behavior, but it omits output format, error behavior, and network dependency.

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

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

The description is short and front-loaded, with no filler. It loses a point because the second sentence adds a behavioral detail about a non-existent title parameter, making it slightly confusing despite being 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?

Given nine parameters, no output schema, and no annotations, the description is far from complete. It defines neither the expected output nor how the parameters relate to the tool purpose, so the tool cannot be invoked correctly from this definition alone.

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

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

None of the nine schema parameters corresponds to a Wikipedia title, and the description provides no mapping from 'title' to any input. The schema descriptions are unrelated to Wikipedia title checking, so a caller cannot determine how to supply the title.

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: checking whether a Wikipedia title exists, which distinguishes it from URL/status/validation siblings. However, the input schema contains no 'title' parameter, so the purpose statement is 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?

The description gives no explicit guidance on when to choose this tool over siblings such as fetch-status or normalize-url, and no when-not-to-use conditions. The only implied usage is the verb phrase itself, which is not enough for routing.

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