JSON Lines row count, body discarded

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

No annotations are provided, so the full burden falls on the description. It adds genuinely useful behavioral facts: task text is discarded and only connection methods are returned. It partially contradicts itself, though – if the task text is discarded, how does the tool 'find a gateway for a task'? The schema's parameter comments add 'discarded after check' detail, but the description itself leaves the core mechanism unexplained. No contradiction with annotations exists since none were supplied.

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

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

The description is a tight two-sentence definition that front-loads the purpose and names the return value. The closing sentence 'Task text discarded' is efficient but ambiguously placed – it is unclear whether 'task text' refers to the whole request payload and undermines the purpose statement that precedes it.

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

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

This is a 9-parameter, heterogeneous tool with no output schema and no annotations, so the description carries a heavy completeness burden. It explains what is returned ('connection methods') but not their form, does not reveal how the tool selects a gateway or what shape checks are performed, and gives no guidance on selecting among the nine parameters. An agent would need substantially more context 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 the baseline of 3 applies. The schema already documents each parameter's meaning (e.g., 'Git ref name; discarded after the shape check'), and the description adds no further semantic detail about parameters. The description's mention of tasks like weather and search loosely maps to 'city' and 'query', but it does not explicitly connect any task to a parameter.

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

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

The description states a clear verb ('Find'), a specific resource type ('public pay-per-call tool gateway'), and concrete task examples (weather, search, scrape, voice). It also discloses the return value ('connection methods'). However, 'tool gateway' is an unconventional concept that is not elaborated, and the description does not distinguish this elastically-scoped tool from its 27 siblings, which all appear to be named shape/fetch/validation 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?

The examples (weather, search, scrape, voice) give implicit context for when this index might be useful, but there is no explicit when-to-use vs when-not-to-use guidance and no mention of alternative tools. More critically, with 9 heterogeneous optional parameters, the description gives no hint about which parameter an agent should fill for which task – an agent cannot tell whether to pass 'city' or 'url' or 'query' to route a given request.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'No browser is launched,' which is a negative constraint, but it does not describe what the check actually does (e.g., network request, DNS resolution, HTTP status) or any side effects. The schema hints at 'shape check' and 'discarded after' but the description adds no clarity, leaving the behavior 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 a single short sentence, which is concise, but it is severely under-specified. It lacks any structure to guide usage and does not earn its place by providing necessary information. The brevity here is a deficiency, not a virtue, given 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 optional parameters, no annotations, and no output schema, this description is wholly inadequate. It does not explain how the parameters relate to the operation, what constitutes a successful check, or how to interpret results. The tool is effectively a black box with a misleadingly simple description, leaving the agent unable 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 the baseline is 3, but the description adds no value in interpreting the parameters. It does not indicate which parameter is the primary URL input or how the various unrelated parameters (city, json, zone) relate to the stated purpose. The schema descriptions themselves are confusing (e.g., 'Git ref name; discarded after the shape check'), and the tool description fails to reconcile them with the claimed URL check.

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

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

The description states a clear verb and resource ('Check whether a URL can be opened'), which is specific. However, the input schema contains 9 unrelated parameters (ref, city, feed, json, path, zone, etc.), and the description does not clarify which parameter represents the URL to check. This ambiguity undermines the purpose clarity, especially given the many sibling tools with similar URL-related functions (e.g., fetch-status, normalize-url).

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 any sibling tools, conditions, or exclusions. There is no context about the intended use case or how to select the correct parameter for the URL check, leaving the agent without direction.

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

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

With no annotations, the description carries full responsibility for disclosing behavior. It only says 'Expression discarded' without explaining what actually happens to the inputs or what the output is. The tool name suggests evaluation, but the description gives no indication of side effects, return value, or error behavior. The mismatch between the purpose and parameters further obscures the tool's true function.

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 clauses) but not concise—it is under-specified and misleading. It omits critical information about the tool's actual behavior and does not earn its brevity. A good concise description would clarify the tool's purpose relative to its parameters, not leave an agent guessing.

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

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

The tool has 9 parameters, no output schema, and no annotations, yet the description provides almost no operational context. It does not explain what happens to each parameter, what the return value looks like, or why a+b arithmetic relates to the given inputs. For a tool with this complexity, the description is 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?

Schema description coverage is 100%, so each parameter has a basic description, but those descriptions are unrelated to the stated arithmetic purpose (e.g., 'Git ref name; discarded after the shape check'). The description does not connect the parameters to the evaluation logic or explain how they relate to 'a+b'. It fails to add meaning beyond the schema and actually confuses the semantics by implying all parameters are discarded.

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

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

The description states 'Evaluate a+b style arithmetic' which suggests a specific verb and resource, but the input schema contains nine unrelated parameters (ref, url, city, feed, host, json, path, zone, query) with no arithmetic expression or a/b fields. The phrase 'Expression discarded' contradicts the stated purpose and makes the actual behavior opaque. It does not clearly distinguish from siblings like validate-json or fetch-status, and could mislead an agent into thinking it performs arithmetic on the provided 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 guidance is provided on when to use this tool versus any of the 28 sibling tools. The description neither mentions alternatives nor specifies conditions for selection. An agent has no basis to decide if calc-eval is appropriate, especially given the mismatched parameters.

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

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

The description discloses a meaningful non-obvious behavior: page content is not stored. It does not cover other side effects, permissions, or errors, but no annotations are present and the operation appears read-only.

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

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

Two short sentences with the main action first and a brief privacy note second; every word carries 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 schema exposes nine optional parameters, several unrelated to URLs, but the description does not clarify that the tool is only for URL host/scheme/status or that other parameters are ignored. With no output schema or annotations, this leaves important context missing.

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

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

Schema descriptions cover 100% of parameters, so the baseline applies. The tool description adds no parameter-level meaning, and it leaves ambiguous whether only the url parameter is actually used.

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

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

The description states a specific action ('Return') and a precise result ('host, scheme, and HTTP status for a URL'), which clearly distinguishes this from sibling tools focused solely on status, normalization, or content fetching.

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 use when host/scheme/status of a URL is needed and hints that page content is not a deliverable, but it does not explicitly say when to prefer this over siblings or name 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?

With no annotations provided, the description must disclose behavioral traits. It only mentions 'No identifiers are retained,' which addresses privacy but not core behavior—whether it performs network calls, modifies state, or returns a specific structure. The description is silent on these aspects.

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 waste, but it is too terse to be genuinely useful. Conciseness is achieved at the expense of essential information, so it is adequate but not exemplary.

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, this description is severely incomplete. It does not explain what classification means, how the inputs are used, or what the response looks like, leaving the agent with insufficient guidance 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%, and each parameter has a clear description (e.g., 'discarded after the shape check'). The tool description itself adds no parameter-level detail, but the schema already carries that load, so the baseline 3 is appropriate.

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

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

The description states a verb ('Show') and a resource ('this request') but the phrase 'how this request is classified' is vague—it doesn't specify the classification criteria, output format, or purpose. It also fails to distinguish the tool from siblings like 'domain-shape' or 'validate-json' which have clearer scopes.

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 offers no context, prerequisites, or examples, 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 does not disclose how the tool handles the many other parameters in the schema, nor does it mention any side effects, permissions, or discard behavior. The annotation set is empty, so the description bears full responsibility but 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 a single, concise sentence with no fluff or redundancy.

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

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

Given the tool has many parameters and no output schema, the description is incomplete. It explains only the core splitting function and leaves the role of other parameters unexplained.

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 only mentions hostname, while the schema includes nine parameters. It does not clarify which parameter is used for the split operation or what happens to the others, adding no value beyond the 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 a specific action (split) and resource (hostname), and includes a qualifier that it does not fetch WHOIS or data, making the purpose 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 gives no explicit guidance on when to use this tool versus alternatives. The phrase 'without WHOIS or data' hints at a distinction but does not name alternative tools or conditions.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It mentions only the HEAD operation and status return, but the schema includes parameters for timezones, JSON validation, file paths, etc., whose behavior is not disclosed. The description is misleading because it implies the tool only handles URLs, while the schema suggests broader functionality. No side effects, permissions, or error conditions are mentioned.

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

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

The description is extremely concise—a single sentence—and the key action is front-loaded. However, the brevity is a result of under-specification rather than efficient writing. It omits critical information about the tool's full scope, so the conciseness is 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?

For a tool with 9 parameters, no annotations, and no output schema, the description is severely incomplete. It explains only one aspect (URL status) and leaves all other parameters and their behaviors unexplained. An agent cannot reliably invoke this tool correctly for any of the non-URL use cases hinted at by the schema. The description fails to provide a complete picture of the tool's capabilities and expected inputs.

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, but the description adds no value beyond the schema. Moreover, the schema descriptions themselves are cryptic (e.g., 'discarded after the shape check') and the description does not clarify them. The tool's single sentence offers no explanation for parameters like 'ref', 'city', 'zone', or 'json', leaving the agent to guess their 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 clear action ('HEAD a public URL') and output ('return status only'), which distinguishes it from generic fetch tools. However, it ignores the other eight parameters in the schema, making the tool's full purpose ambiguous. It doesn't explicitly differentiate from siblings like browser-url-ok or playwright-url-ok, which likely have similar URL-checking functionality.

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 its siblings. The description doesn't mention alternatives or the conditions under which this tool is preferred. An agent would have to infer usage from the name and schema, which is insufficient.

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. It only states that the path is discarded, which is a minor behavioral detail. It does not mention whether the tool makes network calls, validates, or what it returns. This is insufficient for a tool with no annotation coverage.

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, which is concise. However, it sacrifices necessary information for brevity, so it's not well-structured for agent use.

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, a one-sentence description is grossly inadequate. It fails to explain the tool's purpose, return value, or how the extra parameters fit in. This is a major gap.

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

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

The schema covers 100% of parameters, so the baseline is 3. The description adds no parameter information beyond the schema, and it doesn't even reference any of the 9 parameters. The schema descriptions are generic placeholders, but the tool description doesn't clarify how they relate to Figma URL parsing.

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 (Parse) and resource (Figma file URL), and adds a behavioral note that the path is discarded. However, it does not differentiate from sibling URL tools like normalize-url or browser-url-ok, nor does it state what the output is, so it's clear but not distinguishing enough.

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 others. No mention of alternatives or exclusions. An agent would have to infer that this is specific to Figma URLs, but there is no explicit 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 carries the full burden of behavioral disclosure. It only states 'No disk access,' which is a safety guarantee, but fails to explain the return value, what 'safe' means, or how the other parameters are handled. The schema mentions many fields are discarded, but the description omits this context entirely.

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) and front-loads the core action, but it is under-specified. It omits essential details about the tool's behavior and scope, making it more under-specified 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 the tool has 9 optional parameters, no output schema, and no annotations, the description is grossly incomplete. It does not explain what the tool returns, how it validates each input type, or when to use it relative to siblings, leaving an agent unable to use 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?

While the schema provides 100% coverage with descriptions for all 9 parameters, the tool description adds no parameter-level insight and even creates confusion by focusing solely on 'path' while the schema includes many unrelated fields. It does not clarify which parameter is the primary one or how the others relate to the stated purpose, so it fails to add 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 states a clear verb and resource ('Check whether a path looks safe') and a safety note about no disk access, so it is not a tautology. However, the input schema includes eight other parameters (ref, url, city, etc.) that are unrelated to path checking, making the tool's actual scope ambiguous. It also does not differentiate itself from sibling shape-check tools like browser-url-ok or domain-shape.

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

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

The description gives no guidance on when to use this tool versus the many sibling shape-check tools. It does not mention alternatives, conditions for use, or when not to use it, leaving the agent without routing information.

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 behavioral traits, but it only mentions using Open-Meteo. It doesn't describe side effects, network calls, or what happens to inputs. The schema descriptions mention 'discarded' but that is not in the tool description. Minimal 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, concise sentence with no waste, but it is under-specified. It lacks critical details like input selection and differentiation, so it is not appropriately sized 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?

The tool has 9 optional parameters, no output schema, and no annotations. The description is a one-liner that doesn't explain how to invoke it, what the output format is, or how it differs from siblings. This is incomplete for a tool with such a complex schema.

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 all parameters are documented in the schema. The description adds no parameter-specific information, such as which parameter is used for the place. Baseline 3 is appropriate since the schema already covers parameter semantics.

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

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

The description states the tool provides latitude and longitude for a place via Open-Meteo, which is a clear purpose. It does not explicitly differentiate from sibling tools like weather-hint, but the mention of coordinates makes it distinct. However, it doesn't indicate how the place is specified, which is a 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?

The description gives no guidance on when to use this tool versus alternatives. It does not mention any conditions, exclusions, or alternative tools. An agent would have to infer usage solely from the purpose, which is insufficient given the large sibling list.

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 mentions parsing, but does not disclose what happens on invalid URLs, whether the tool performs network calls, what it returns, or that many inputs are discarded. The schema hints at discarding behavior (e.g., 'discarded after the shape check') but the description adds no such 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, concise sentence with no wasted words. It is appropriately front-loaded with the core action. However, it is so minimal that it sacrifices necessary detail, which slightly reduces the score from 5.

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

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

Given the complexity of 9 parameters, no annotations, and no output schema, the description is woefully inadequate. An agent cannot determine which parameters are relevant, how to construct a valid call, what the output format is, or what edge cases exist. The description provides almost no contextual information needed for correct invocation.

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

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

The schema coverage is 100%, so baseline is 3, but the description adds zero parameter meaning. Worse, the schema descriptions are inconsistent with the tool purpose: 'url' is described as 'HTTPS URL to normalize or cite' instead of a GitHub URL, and other parameters (city, feed, etc.) have no relation to the stated function. The description does not clarify which parameter is the primary GitHub URL or how others are used.

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

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

The description states a specific action ('parse owner and repo') on a specific resource ('GitHub URL'), which is clear in isolation. However, the input schema lists nine unrelated parameters (city, feed, host, json, path, zone, query, etc.) with no required fields, implying the tool does far more than parse GitHub URLs. This disconnect makes the stated purpose incomplete and potentially misleading 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?

There is no guidance on when to use this tool versus siblings like 'figma-url-shape' or 'normalize-url'. No preconditions, alternatives, or exclusions are mentioned. The description simply states what it does without contextual 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, and the description does not disclose side effects, authentication requirements, rate limits, or output format. The presence of many unrelated optional parameters makes the tool's actual behavior even more 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 to the point, containing only two sentences. 'Titles discarded' adds a bit of clarification but is somewhat ambiguous; still, there is no significant fluff.

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

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

The tool has no output schema and its description does not explain how any of the 9 optional parameters affect the count. Given the mismatched and irrelevant parameter descriptions, the context is far from complete.

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

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

Although the schema description coverage is 100%, every parameter description is unrelated to counting Hacker News front-page stories (e.g., 'Git ref name', 'IANA timezone name'). This provides no meaningful semantics for how the parameters should be used.

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

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

The description clearly states the action ('count') and the resource ('Hacker News front-page stories'), which gives a solid sense of purpose. However, it does not distinguish this tool from sibling tools that might also access HN content, such as web-fetch.

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

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

There is no guidance on when to use this tool versus alternatives. The phrase 'Titles discarded' hints at output behavior but does not explain usage conditions or prerequisites.

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

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

With no annotations provided, the description must disclose behavior on its own. It fails to indicate whether the tool returns a list, validates input, or has side effects. The sentence only states a topic, not any observable behavior or constraints, leaving the agent completely in the dark.

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 waste, but it is under-specified to the point of being uninformative. Conciseness is only a virtue when the content is sufficient; here it lacks essential detail about the tool's operation, making the brevity a defect rather than an asset.

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 parameters, no annotations, and no output schema, the description is severely incomplete. It does not explain what the tool returns, which parameters are used, how it relates to clock calls, or any preconditions. An agent cannot infer how to call it correctly or interpret results.

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% and each parameter has a description, so the baseline is 3. However, the tool's description does not clarify which of the 9 parameters are relevant to its stated purpose; most parameters (ref, url, city, etc.) appear unrelated to timezone names. The description adds no semantic value beyond the schema, and the mismatch between the description and the parameter set confuses rather than clarifies.

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' is vague; it does not state a clear action (list, validate, fetch) or a specific resource beyond a generic 'names'. It does not distinguish from sibling tools like 'timezone' or 'utc-time', which likely perform the actual clock operations. The purpose is implied but not concrete.

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 does not mention that it should be called before a clock operation, nor does it reference any sibling tools or exclusion criteria. An agent would not know if this tool is required, optional, or a fallback.

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 mentions that only group counts are returned, but it does not disclose network behavior, error handling, timeouts, or whether it performs any side effects. It also does not mention that many parameters are discarded, though that is noted in the schema. The description is too thin to inform an agent about operational risks or limitations.

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, very concise and front-loaded. There is no wasted wording. However, it is so terse that it omits essential context, but the conciseness itself is appropriate; the issue is under-specification rather than verbosity.

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

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

With 9 parameters, no annotations, and no output schema, the description is severely incomplete. It does not explain how to specify the target robots.txt URL, what constitutes a 'group', what the return format is, or how failures are communicated. An agent cannot confidently invoke this tool correctly based on the provided 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?

While the schema description coverage is 100%, the parameter descriptions are generic and do not tie to the tool's purpose (e.g., 'url' is described as 'HTTPS URL to normalize or cite' rather than a robots.txt URL). The tool description does not clarify which parameter is the target for fetching robots.txt, leaving an agent to guess. This is a significant gap given the tool has 9 parameters, many of which are unrelated to the described action.

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 ('Fetch a public robots.txt') and a specific output ('return group counts only'), which distinguishes its core function. However, it does not differentiate from sibling tools like web-fetch or fetch-status, and the input schema has no parameter that explicitly references robots.txt, so the mapping between the description and the parameters is unclear.

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 web-fetch or fetch-status. No context is provided about scenarios where group counts are needed, nor any mention of when not to use it. The description implies a specific use case but leaves the selection 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?

No annotations are present, so the description carries full burden. It only notes 'Key discarded,' which is ambiguous and does not disclose whether the tool makes network calls, is read-only, or what happens to the other input 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 terse (two short sentences), but this is under-specification rather than effective conciseness. It omits essential information about parameter usage and expected behavior.

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

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

For a tool with 9 optional parameters, no annotations, and no output schema, the description is grossly inadequate. It does not explain how the parameters relate to the Jira key check, what the tool returns, or any prerequisites.

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 generic and none clearly correspond to a 'Jira key.' The description does not map the 'key' concept to any of the 9 parameters, leaving the agent unsure which input to provide. The 100% schema coverage does not compensate for the lack of integration with the 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?

States a clear verb ('check') and a specific resource ('Jira issue key shape'), which distinguishes it from sibling shape-checkers like domain-shape or github-repo-shape. However, 'shape' is undefined, leaving ambiguity about what is validated.

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 versus alternatives. The description does not mention any context, exclusions, or relationships to other shape-checking tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'body discarded', indicating that the content is not returned, which is one behavioral trait. However, it does not disclose whether the tool performs network calls, accesses disk, or has side effects. The schema parameter descriptions hint at no disk access for 'path', but that is in the schema, not the description. This is insufficient for an agent to understand the tool's 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 phrase, which is under-specified rather than concise. It lacks a full sentence and does not front-load key information beyond the core action. There is no structure to guide the agent, and the brevity comes at the cost of necessary details.

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

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

For a tool with 9 parameters, no output schema, and no annotations, the description is grossly incomplete. It does not explain what the tool does with each parameter, what the return value is (presumably the row count), or when to use it. The description alone leaves nearly all critical information missing, making it inadequate for correct usage.

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, but the tool description adds no value in clarifying which parameter is the primary input. The schema itself lists nine diverse parameters with generic descriptions like 'JSON text to validate' and 'File path to check', but the description does not map 'JSON Lines row count' to any specific parameter. This ambiguity undermines the agent's ability to construct a correct call.

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 ('JSON Lines row count, body discarded') which implies counting rows in JSON Lines data and discarding the content. However, it does not specify which parameter holds the JSON Lines input, leaving the agent to guess among 'json', 'path', or others. It is not a tautology but is vague about the exact resource being operated on.

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 its siblings such as validate-json or fetch-status. There is no mention of context, prerequisites, or alternative tools. An agent has no basis to decide whether to call this tool instead of another.

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 mentions 'Body discarded' but says nothing about side effects, network behavior, or how inputs are processed. The description is too vague to convey what happens when the tool is invoked.

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 that's under-specification, not conciseness. It omits essential information and provides no structure or front-loading of critical 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 parameters, no output schema, and no annotation support, the description is drastically incomplete. An agent cannot determine what inputs are relevant, what the tool returns, or how to interpret the result. This is far below the minimum viable description for such a complex 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 schema covers all parameters with individual descriptions, but the tool description doesn't tie them together or explain how they relate to the stated purpose. Most parameters (city, json, zone) are irrelevant to 'HTTP status for a library docs URL', so the description fails to add meaning 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 claims the tool returns HTTP status for a public library docs URL, but the input schema includes 9 unrelated parameters (city, JSON, timezone, etc.), so the stated purpose is narrow and misleading. It doesn't clearly state what the tool actually does with the variety of inputs, and the name 'lib-docs-hint' doesn't resolve the 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 on when to use this tool versus its many siblings (browser-url-ok, fetch-status, weather-hint, etc.). The description offers no context about selection criteria or exclusions, leaving the agent to guess.

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. It does disclose that values are discarded, but it does not explain the effect of passing multiple parameters, error behavior, or whether the tool performs any side effects. This is minimal transparency for a tool with 9 unrelated 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 concise at one sentence, but it is under-specified rather than efficiently structured. It front-loads the core operation but omits essential selection details, making it superficially brief yet functionally incomplete.

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

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

The tool has 9 parameters, no required parameters, no output schema, and no annotations. The description provides neither the input mapping nor the exact return value (e.g., integer count, nested key behavior), nor any error handling. This is severely inadequate for an agent to call the tool correctly.

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

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

The schema descriptions cover 100% of parameters and even note discarding behavior for most, so the baseline is 3. However, the description adds no mapping from parameters to the JSON input, leaving it ambiguous which parameter is actually counted. The description fails to compensate for the high parameter count and unclear 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 a clear operation (count keys in a JSON object) and mentions discarding values. However, it does not specify which of the 9 parameters contains the JSON, nor does it distinguish itself from sibling tools like validate-json or json-lines-ok. This ambiguity makes it only mildly clear.

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

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

No guidance is given on when to use this tool versus alternatives. There is no mention of scenario, prerequisites, or when not to use it. The description is a bare statement of function, leaving the agent to guess 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 must disclose all behavioral traits. It reveals that query and fragment are dropped, but it does not address what happens with the other parameters (e.g., ref, city, json) or whether any side effects occur. The schema hints these are 'discarded' but the description omits them entirely, leaving the tool's 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 two sentences with no waste, front-loading the core function and a key behavioral detail. It is efficiently structured and easy to parse, earning top marks for conciseness.

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

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

Given the tool has nine parameters, no output schema, and no annotations, the description is notably incomplete. It fails to explain the role of the non-URL parameters, specify the return format, or note any constraints like required inputs or error conditions. A more thorough description is needed for correct invocation.

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

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

Schema coverage is 100%, so each parameter has a description, meeting the baseline. The tool description adds no additional meaning about parameters, and the parameter descriptions themselves are oddly unrelated to URL normalization (e.g., city, zone), which the description does not reconcile. Thus it neither improves nor worsens the schema's adequacy.

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

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

The description states a specific verb ('Return') and resource ('origin, host, and path for a URL') with a clear behavior (dropping query and fragment). It distinguishes the main function from siblings like browser-url-ok or fetch-status, though the presence of nine unrelated parameters in the schema muddles the intended 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?

No guidance is given on when to use this tool versus alternatives. It does not mention conditions, prerequisites, or exclusions, leaving the agent to infer when normalization is appropriate compared to sibling tools like browser-url-ok or citation.

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 mentions 'No browser is launched' but fails to explain what the check actually entails (HTTP request, DNS lookup, format validation). The presence of parameters like city, zone, and query that are 'discarded' suggests a broader shape-check tool, contradicting the narrow 'URL' framing, making 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 very concise—two sentences with no waste. The main purpose is front-loaded, and the clarifying note about browser launch is added. It's efficient, though it could arguably be longer to cover critical gaps.

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 heterogeneous parameters, no annotations, and no output schema, the description is severely incomplete. It doesn't explain what 'opened' means, what the tool returns, how non-URL parameters are handled, or why they are discarded. An agent cannot confidently call 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 coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning beyond the schema; it doesn't clarify how parameters like city, zone, or query relate to the URL check. Since the schema already documents each parameter, the description provides no additional semantic value.

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 purpose: checking whether a URL can be opened, and explicitly notes that no browser is launched. This differentiates it from browser-url-ok, though 'opened' is somewhat ambiguous (syntax vs. HTTP reachability).

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 versus alternatives like fetch-status, normalize-url, or browser-url-ok. The only hint is 'No browser is launched,' which implies use when browser launch is undesired, but it doesn't explicitly mention alternative tools or conditions for selection.

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

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

With no annotations provided, the description carries the burden of disclosing side effects; it does state 'Query discarded,' indicating the input is not persisted. However, it does not mention error behavior, rate limits, authentication, or the fact that the many other schema parameters appear to be ignored.

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

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

The description consists of two short sentences with no unnecessary words. Both sentences earn their place: the first states the core action and the second discloses disposal behavior.

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

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

The tool has nine optional parameters and no output schema, but the description does not state the return value or type, nor does it explain the unrelated parameters. This leaves the tool incomplete for reliable selection and invocation in the given context.

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

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

Schema coverage is 100%, so the baseline is 3 and the main description adds little beyond the existing 'query' parameter description. It does not clarify why the schema includes unrelated parameters like url, json, path, or zone, leaving their role ambiguous.

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

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

The description clearly states a verb ('Count characters') and a resource ('search query'), and it notes the query is discarded. However, the input schema exposes eight additional unrelated parameters, which muddies the actual scope and makes the tool less distinct from 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 does not explicitly say when to use this tool versus alternatives such as other validation or counting tools. The phrase 'search query' implies a use case, but no concrete when-to-use, when-not-to-use, or alternative guidance is provided.

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

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

With no annotations, the description carries the full burden, yet 'Short catalog of common HTTP status codes' discloses no side effects, network access, or return behavior. Only the schema parameter notes ('discarded after the shape check', 'no disk access', 'titles discarded') hint at non-usage of inputs, and those live outside the description itself.

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 nine-word noun phrase with no wasted words and is front-loaded with the topic, so it is concise. However, it is under-sized for a tool with nine parameters and offers almost no actionable structure for an agent deciding how to invoke it.

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

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

With nine parameters that appear unrelated to the stated purpose and no output schema, the one-line description leaves the input/output contract almost entirely unexplained. An agent cannot predict what the tool does with a city name, a Git ref, or a timezone, nor what the catalog returns.

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 per-parameter notes do add some meaning beyond bare names (discard semantics, 'no disk access', 'titles discarded'), but several notes describe behaviors recycled from other tools (weather hint, timezone, URL normalization, JSON validation) and never connect the parameters to the catalog's 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 names a resource ('short catalog of common HTTP status codes') but uses no action verb and never says what the tool actually does with its inputs. The nine optional parameters (git ref, city, timezone, RSS feed, JSON text, file path) bear no visible relationship to an HTTP status-code catalog, leaving the tool's true function 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 call this tool versus siblings like fetch-status, normalize-url, weather-hint, or validate-json. There is no 'use when', 'use instead', or any comparative language anywhere in 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, the description carries the full burden of disclosing side effects. 'Prompt discarded' hints that input may be ignored, but it is vague and does not clarify whether the tool is read-only, modifies state, or has any other behavioral implications.

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. It is front-loaded with the primary action and contains no filler.

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

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

The description omits essential context such as what the three-step template contains, whether any parameters are actually required, and why the prompt is discarded. The presence of many seemingly irrelevant parameters further undermines completeness.

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

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

Although the schema has 100% description coverage, the parameter descriptions are unrelated to the stated purpose of returning a thinking template. The tool description adds no explanation of how these nine parameters relate to the template, creating 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 states a specific action and deliverable: 'Return a three-step thinking template.' This clearly identifies the tool's core purpose. However, it does not distinguish itself from sibling tools, and the phrase 'Prompt discarded' adds ambiguity about what the tool actually consumes.

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

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

There is no guidance on when to use this tool versus alternatives like calc-eval, validate-json, or fetch-status. No mention of suitable scenarios, prerequisites, or conditions that would make this tool the right choice.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the timezone feature and says nothing about side effects, what happens to the other eight parameters (e.g., they are discarded or used for other checks), or whether the tool performs additional validations. The schema hints at discarding behavior, but the description itself is silent, leaving the tool's 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 a single sentence with no waste, making it concise and front-loaded. It is appropriately sized for a simple tool, though given the schema complexity, a touch more context would be warranted. Still, it avoids bloat and is 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?

The tool has nine parameters but the description only explains one function. There is no mention of what the other parameters do, whether they are optional, or how they relate to the timezone feature. No output schema exists, so the return format is unspecified. Given the complexity of the schema, the description is inadequate for an agent to call the tool correctly without risking misuse of the other parameters.

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. The description adds value by specifying that the timezone is IANA, which clarifies the 'zone' parameter. However, it fails to explain why nine parameters exist when the tool only claims to provide time, and it does not compensate for the potential confusion about which parameters are relevant. The baseline 3 is appropriate because the schema covers semantics but the description does not clarify the overall parameter intent.

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 ('Current time') and resource ('named IANA timezone'), making the primary purpose clear. However, it does not differentiate from sibling tool 'utc-time', which likely overlaps, and it ignores the 9-parameter schema that suggests broader functionality. The one-liner is unambiguous but leaves the agent uncertain about 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?

No guidance is given on when to use this tool versus alternatives like 'utc-time' or 'iana-zones'. The description offers no context about prerequisites, suitable inputs, or when it should be preferred. An agent would have to infer usage from the schema, which lists many unrelated parameters, increasing confusion.

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 behavioral traits. It does not state whether the tool is read-only, what it returns (beyond a timestamp), whether parameters are ignored, or any side effects. For a simple tool this might be acceptable, but the complete lack of behavioral disclosure 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 concise sentence with no fluff, which is good for front-loading. However, it is so minimal that it fails to convey the tool's actual behavior or the relevance of its parameters. It is under-specified rather than efficiently structured.

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 extremely incomplete for an agent to call correctly. It has 9 optional parameters that appear unrelated to the stated purpose, no output schema, and no annotations. The description does not clarify what the parameters do or how they affect the result, leaving an agent with almost no guidance on how to invoke the tool meaningfully.

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

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

The schema descriptions cover all 9 parameters at 100% coverage, and each parameter's description explicitly notes it is 'discarded' or used only for validation. However, the tool description adds no meaning beyond the schema—it does not explain how these parameters relate to the UTC timestamp output. The schema already carries the burden, so a baseline 3 is appropriate.

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

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

The description 'Current UTC timestamp' clearly indicates the tool returns the current UTC time, but it is phrased as a noun phrase rather than an action, and it does not distinguish itself from siblings like 'timezone' or 'iana-zones'. The presence of 9 unrelated optional parameters further muddies the purpose, as the description gives no hint that they are validation-only and not used for output.

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 'timezone' or 'iana-zones'. The description does not mention any preconditions, exclusions, or alternative tools. An agent must infer 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?

No annotations are provided, so the description must carry the full behavioral burden. It only discloses that the body is discarded, which hints at no persistence, but it omits other important behaviors like whether network requests are made (given the URL parameters), whether authentication is needed, or how errors are reported. For a tool with 9 parameters, this is insufficient behavioral disclosure.

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 with no filler. It is appropriately sized for the minimal information it conveys, though it could be restructured to be more informative. The front-loading of 'Check whether a body is valid JSON' is acceptable, but the lack of detail keeps it from scoring 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 and no output schema, the description is inadequate. It doesn't explain the role of most parameters (e.g., url, city, host) which seem unrelated to JSON validation, leaving an agent unsure which parameter to supply. It also doesn't describe return values or error behavior. This is a complex tool that needs more 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?

Schema coverage is 100%, and every parameter has a description. The tool description itself adds no new parameter semantics—it only says 'body' without mapping to the 'json' parameter. Since the schema already explains each parameter, the baseline of 3 is appropriate; the description neither enhances nor contradicts 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 clear verb ('check') and resource ('valid JSON'), and mentions the body is discarded, which implies a validation-only operation. However, it is vague about what 'body' means—it doesn't explicitly tie it to the 'json' parameter in the schema, and it doesn't differentiate from the sibling json-lines-ok tool. Still, the core purpose is reasonably clear.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention json-lines-ok or any other sibling that might be more appropriate for JSON-lines validation, nor does it state prerequisites or scenarios. The description offers no usage context whatsoever.

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 transparency burden. It does disclose that an external provider (Open-Meteo) is used and that the output is a temperature, but it omits network/rate-limit/failure behavior and doesn't reveal that many parameters are discarded after a check (per the schema). The description also doesn't clarify the tool's actual 'hint' nature versus returning authoritative meterological 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 a single seven-word sentence with no filler, front-loaded with the key fact ('current temperature'). It's appropriately terse under the conciseness dimension, even though that brevity creates gaps in other dimensions.

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

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

For a tool with nine optional parameters and no annotations or output schema, the description is incomplete. It covers only one parameter (city), doesn't explain what happens when multiple/all parameters are provided, and doesn't give the return shape beyond the bare word 'temperature'. An agent cannot reliably invoke the tool in all its supported modes.

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 value for 'city' by linking it to an Open-Meteo temperature lookup, but says nothing about the other eight parameters (ref, url, feed, host, json, path, zone, query) that are fully described 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 statement identifies a specific resource ('current temperature') and a specific provider ('Open-Meteo'), and the subject is clearly a city. None of the 29 siblings claim weather functionality, so an agent could pick this tool for a weather forecast request. However, it describes only one behavior for a schema with nine optional parameters and doesn't mention any hint of the 'hint' semantics the name implies.

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

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

No when-to-use vs. when-not-to-use guidance is given. The description doesn't name an alternative (e.g., geo-hint or fetch-status), doesn't say when to use the other eight parameters, and doesn't specify any exclusion conditions. An agent would have to infer the full decision from the name and schema alone.

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

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

No annotations are provided, so the description carries the full burden. It does disclose that the body is discarded and that several params are 'discarded after' their check, which is honest about side effects. But it does not disclose return format, error behavior, rate limits, or the ambiguous relationship between the many params.

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, no filler, and the key facts are front-loaded. Every word earns its place; brevity is a genuine strength here.

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

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

This is a 9-parameter tool with no output schema and no annotations, yet the description is only two sentences. It does not explain whether params are alternatives, checked simultaneously, or representative of distinct sub-modes. An agent cannot reliably invoke it across its parameter range based on the current description.

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 baseline is 3. The description adds minimal param-level meaning and actually creates a mismatch by describing only the URL case while the schema documents weather, timezone, JSON, refs, and search. It adds the 'discarded' context but does not help reconcile the param diversity with 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?

States a specific verb+resource ('HTTP status and content type for a public URL') and a notable behavior ('Body discarded'). However, the 9-parameter schema spans weather, timezone, JSON validation, search length, file paths, and refs, so the description covers only a fraction of what the tool accepts and contradicts the breadth implied by the params. It also does not distinguish itself from siblings like fetch-status or browser-url-ok.

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

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

No when-to-use, when-not-to-use, or alternative guidance. With many close siblings (fetch-status, normalize-url, browser-url-ok, playwright-url-ok, inspect-robots), an agent has no way to select this tool over them based on the description 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that the title is discarded after the call, which is a minor detail, but it does not explain network access, rate limits, or the return format. This is insufficient for a tool that likely makes an external request.

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—a single sentence—but it is under-specified rather than appropriately concise. It omits critical information about parameter mapping and output, so the brevity does not serve the user.

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 grossly incomplete. It fails to explain which parameter is the title, what the response looks like, or any error conditions. An agent cannot safely or correctly invoke this tool based on the given definition.

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

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

Although schema description coverage is 100%, the parameter descriptions do not connect to the Wikipedia title. None of the nine parameters (ref, url, city, feed, host, json, path, zone, query) is identified as the title, so the agent cannot know which field to populate. The description adds no mapping value beyond the schema, leaving the tool effectively unusable without additional 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 clearly states the tool checks whether a Wikipedia title exists, which is a specific verb+resource and differentiates it from siblings like browser-url-ok or fetch-status. However, it does not specify which input parameter corresponds to the title, which slightly muddies the 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 any of its 29 siblings, nor does it mention any conditions or prerequisites. An agent would have 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.