ETag shape, value discarded

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

With no annotations, the description carries full responsibility for disclosing behavior. The description claims the tool returns connection methods and finds gateways, but the schema indicates each parameter is discarded after a shape or length check. This misrepresents the actual behavior, which appears to be validation rather than gateway lookup. It also doesn't disclose that inputs are discarded, except through schema hints. The description is misleading and contradictory.

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

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

The description is only one sentence, which is concise in length, but it lacks essential information. It fails to front-load the actual function or clarify the ambiguous purpose. Conciseness should not come at the expense of clarity; here it is under-specified rather than efficiently informative.

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

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

For a tool with 9 optional parameters and no output schema, the description is grossly incomplete. It doesn't explain what the tool actually does, what the return format looks like, how parameters relate to the gateway-finding claim, or when it should be used. Without annotations, the description fails to provide any meaningful context. It is inadequate for an agent to understand or correctly invoke the tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The schema descriptions are clear about each parameter's purpose (e.g., 'discarded after the shape check'). The top description adds no parameter meaning and even conflicts with the schema's implied validation purpose. Since the schema is adequate, the description doesn't need to add much, but it also doesn't clarify the relationship between parameters and the stated gateway-finding purpose. Thus, 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 states a purpose ('Find a public pay-per-call tool gateway') but is vague and confusing. It doesn't specify what 'connection methods' are, and it mentions 'task text discarded' while no task parameter exists. The purpose conflicts with the parameter schema, which suggests validation of individual inputs rather than gateway discovery. It is not a tautology but lacks specificity and fails to differentiate from sibling tools.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention any sibling tools or exclusions. For instance, for weather tasks, weather-hint exists, but the description doesn't clarify when this tool should be preferred. There is no when-not-to-use 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?

The description discloses one behavior (no browser is launched) but does not mention whether it makes a network request, whether it is read-only, what it returns, or how failures are reported. With no annotations, more behavioral disclosure is needed.

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, front-loads the purpose, and contains no fluff. Every sentence earns its place.

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

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

For a tool with nine optional parameters, no output schema, and many siblings, the description is too sparse: it does not clarify expected output, error semantics, or the role of the extra parameters. This leaves an agent uncertain how 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?

The description does not map its purpose to the input schema's parameters; it mentions 'a URL' but never identifies the url property as the relevant one, and the schema contains many unrelated optional fields. The schema descriptions are present, but the tool description adds no guidance about which parameter is used or that the others are ignored.

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

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

The description states a specific action (check whether a URL can be opened) and resource (URL), and the 'No browser is launched' note differentiates it from browser-based tools like playwright-url-ok. It is slightly vague about what 'can be opened' means (HTTP reachability vs. browser compatibility).

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

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

No explicit guidance is given for when to use this tool instead of siblings such as web-fetch, fetch-status, normalize-url, or playwright-url-ok. 'No browser is launched' is a behavioral constraint, not a usage recommendation.

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, and the description's phrase 'Expression discarded' is contradicted by the absence of any expression input. The tool's behavior, side effects, and return value are completely unspecified.

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

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

The description is extremely brief, but its brevity comes at the cost of clarity. It omits essential information about what the tool actually does and how the parameters are used, making the concise structure ineffective.

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, no output schema, no annotations, and no usage guidance, the tool definition leaves nearly every contextual detail unspecified. An agent cannot predict the tool's behavior or integrate 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?

Although every parameter has a description, none of those descriptions relate to arithmetic evaluation. Parameters like 'url', 'city', and 'feed' are described as discarded or checked, but their role in the tool is unclear, and there is no parameter that could hold the arithmetic expression mentioned in the description.

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

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

The description claims to evaluate a+b arithmetic, but the input schema contains no expression parameter and instead lists nine unrelated string parameters with descriptions such as 'Git ref name' and 'City name'. This makes the tool's actual purpose impossible to discern, and it does not distinguish itself from the many sibling tools.

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

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

No guidance is provided on when to use calc-eval versus any alternative tool. The description and schema do not indicate what problem this tool solves, so an agent cannot determine appropriate usage.

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

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

The description discloses one behavioral trait: 'Page content is not stored'. However, it does not disclose that the tool accepts many unrelated inputs (ref, city, feed, json, path, zone, query) that are apparently discarded after validation, which is a significant hidden behavior given the tool's name and stated URL-focused purpose.

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

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

The description is a single, front-loaded sentence that states the primary action immediately and adds a clarifying constraint. It is appropriately sized with 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?

Despite the complex 9-parameter schema with seemingly unrelated fields (git refs, weather hints, RSS feeds, JSON validation, file paths, timezones, search queries), the description only covers the URL aspect. It does not explain the tool's broader shape-check/discard behavior or how this fits with its name 'citation', leaving the overall context 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 the baseline is 3. The description does not add meaning beyond the schema—it does not explain how the nine parameters relate to the stated URL purpose or clarify the role of parameters like ref, city, or zone, leaving the overall parameter semantics 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 states a specific action ('Return host, scheme, and HTTP status for a URL') with a clear resource, which is more concrete than a mere tautology. However, it does not explicitly differentiate from closely related sibling tools like web-fetch, fetch-status, or normalize-url, and the 9-parameter schema suggests a much broader multi-purpose behavior that the description does not reflect.

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 tools (web-fetch, fetch-status, normalize-url, etc.). There is no mention of prerequisites, suitability criteria, or scenarios where alternatives would be preferred.

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 and parameter notes disclose that identifiers are not retained and that values are 'discarded' or checked without side effects, which is useful. However, they do not explain what the tool actually does with the supplied values, what it returns, or what side effects, if any, occur beyond retention.

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 and the parameter notes are compact, so there is no verbose or redundant filler. It is concise, though the brevity comes at the cost of clarity.

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

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

With no output schema, no required parameters, and nine heterogeneous optional inputs, the description gives an agent almost no idea of what request to construct or what result to expect. It is not complete enough for reliable tool selection or 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?

All nine parameters have schema descriptions, many with useful hints such as 'JSON text to validate' or 'IANA timezone name', so coverage is complete. The descriptions still do not tie the parameters to a coherent purpose, and several notes like 'discarded after the length check' explain lifecycle rather than meaning.

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

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

The description says 'Show how this request is classified' but does not define what classification means, what categories exist, or what input is being classified. The tool name 'compatibility' hints at a purpose, but the description alone leaves the core 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?

There is no guidance about when to use this tool or when to prefer any of the sibling tools such as normalize-url, validate-json, or weather-hint. The description only states a privacy property, not a usage context.

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

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

With no annotations and a terse description, there is no indication of side effects, data access, or safety profile. The mention of 'discarded after the shape check' hints at ephemeral handling but is too vague to be informative.

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

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

The description is brief but not well-structured. The single sentence mixes a functional statement with a negative qualifier, and the parameter descriptions are formulaic, adding length without clarity.

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

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

Given the tool's complexity (9 optional parameters, no output schema), the description is severely incomplete. It does not explain what 'shape check' means, what the expected output is, how parameters are used, or any return format, leaving the agent without essential 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?

Although each parameter has a description, the descriptions are generic, misleading, or unrelated to the purported hostname-splitting functionality. For example, 'ref' is labeled as a 'Git ref name' and 'city' as a 'City name for a public weather hint', which do not align with the tool's stated purpose, providing no meaningful semantics.

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

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

The description states a specific action ('split a hostname into labels') but the parameter list contains many unrelated fields, making the tool's actual purpose ambiguous. The phrase 'without WHOIS or ownership data' adds confusion rather than clarification.

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 sibling tools like normalize-url or browser-url-ok. The description offers no context for selection or exclusion.

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

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

With no annotations, the description carries the transparency burden. It discloses only that it uses HEAD and returns status, plus a few side-effect hints in parameter descriptions ('discarded', 'no disk access'). It does not mention redirects, error handling, network behavior, or whether non-2xx responses are treated as failures.

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 succinct sentence that front-loads the main verb/resource/result. No filler 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?

Despite 100% parameter coverage, there is no output schema or mention of return format, status representation, redirect policy, or failure semantics. The nine optional parameters are not tied together, leaving an agent unsure how to choose among them or what the tool actually does with most of them.

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 parameter descriptions add some side-effect semantics ('discarded after the shape check', 'no disk access'), but several parameters (city, zone, query, json) do not clearly connect to the stated purpose of HEADing a public URL, and their selection criteria are unclear.

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

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

Description states a clear action and result: 'HEAD a public URL and return status only.' This distinguishes it from full-content fetch tools, but the input schema includes many unrelated optional parameters (city, zone, query, path) that muddy the overall purpose.

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

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

No guidance is given about when to use this tool versus siblings such as web-fetch, browser-url-ok, or playwright-url-ok. The phrase 'return status only' implies a lightweight check, but there is no explicit when-to-use or when-not-to-use.

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 full responsibility for behavioral disclosure. It only mentions that the path is discarded and that it parses a URL, but it does not state what the tool returns, whether it validates or normalizes, or what happens on invalid input. This is insufficient for an agent to anticipate 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 extremely concise, two short sentences with no filler. It is efficiently structured, though the brevity comes at the cost of substance. As a conciseness measure, it scores well; it is not bloated.

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

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

For a tool with 9 optional parameters and no output schema, the description is inadequate. It does not explain what the parsed result looks like, how the output is delivered, or when to use this tool among the many URL-related siblings. An agent would be left guessing about expected outcomes.

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

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

Schema description coverage is 100%, so the schema already documents all 9 parameters. The description adds no extra meaning about parameters, so the baseline of 3 applies. It neither clarifies 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 clearly states the verb 'parse' and the resource 'Figma file URL', and adds a specific behavioral note ('Path discarded'). However, it does not differentiate from sibling tools like normalize-url or browser-url-ok, leaving the agent to infer when this tool is the right choice.

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

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

No guidance is provided on when to use this tool versus the many URL-related siblings. The description offers no context about appropriate use cases, conditions, or exclusions.

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

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

The description explicitly states 'No disk access,' which is a valuable behavioral guarantee. With no annotations provided, the description carries the full burden, but it only covers this one aspect. It does not disclose whether the tool is read-only, what it returns (e.g., boolean, status), or how it handles invalid inputs. For a validator with nine parameters, more behavioral detail is expected, so this is adequate but incomplete.

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

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

The description is extremely concise at two sentences, which is efficient. However, it is under-specified for the tool's actual breadth (9 parameters, multiple validation types). Conciseness alone does not make it effective; it omits essential context about the other parameters and the tool's general purpose. It is appropriately short but not sufficiently informative.

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's complexity (9 optional parameters, no output schema, no annotations), the description is incomplete. It does not explain what 'safe' means, how the tool handles the other parameter types, or what the return value indicates. The lack of an output schema and annotations means the description must carry more weight, but it leaves agents without enough information to use the tool correctly beyond the path case.

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

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

Schema description coverage is 100%, so each parameter already has a description. The tool description adds no additional meaning beyond repeating 'path' and 'no disk access,' which is already in the schema. Since coverage is complete, a baseline of 3 is appropriate; the description does not need to compensate, but it also does not add value beyond the schema.

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

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

The description states the tool checks whether a path looks safe and explicitly notes no disk access, which is clear for the path use case. However, the input schema includes eight other unrelated parameters (ref, url, city, feed, host, json, zone, query), and the description does not mention that the tool can validate these or that it is a multi-purpose validator. This creates ambiguity about the tool's true scope, so purpose clarity is only partial.

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

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

No usage guidance is provided. The description does not say when to use this tool versus the many sibling shape-checkers (e.g., browser-url-ok, figma-url-shape, wiki-title-ok). It also does not explain that different parameters are appropriate for different validation needs or mention any exclusions. Agents must infer applicability from the parameter names 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, the description carries the full burden for behavioral disclosure. It mentions Open-Meteo, implying an external network call, but does not describe side effects, error behavior, input retention, or whether the operation is read-only.

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

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

The description is a single sentence with no unnecessary words, and the schema descriptions are terse. It is compact and easy to scan, though the brevity contributes to ambiguity.

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

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

The definition is incomplete for the complexity involved. There are nine optional parameters, no required inputs, no output schema, and no explanation of how to construct a valid place request or what the response format will be.

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

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

Although every parameter has a schema description, most descriptions are generic and not aligned with the geocoding purpose. City and query are plausible place inputs, but ref, url, feed, host, json, path, and zone are not clearly connected to returning latitude and longitude.

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 returns latitude and longitude for a place via Open-Meteo, which conveys the basic purpose. However, it is a noun phrase rather than a verb phrase, and the schema contains many unrelated fields (ref, json, path, zone) that obscure which input actually identifies the place.

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

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

No guidance is given about when to prefer this tool over alternatives such as weather-hint or normalize-url. The only implied use is geocoding a place, but there is no explicit comparative or conditional guidance.

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

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

No annotations are provided, and the description only mentions 'Parse', which implies a pure read-only operation but gives no details about error handling, edge cases, or effects on the system. The tool's behavior beyond the basic parsing action is not disclosed.

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 that directly states the tool's function. It is front-loaded with the action and object, contains no filler or redundancy, and is easy to parse quickly.

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 the output format, whether any parameters are required, how the tool handles malformed or non-GitHub URLs, and what the returned owner/repo structure looks like. With no output schema and minimal description, an agent lacks sufficient detail to confidently integrate the tool.

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

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

Although schema coverage is 100%, most parameter descriptions are clearly copied from unrelated tools (e.g., 'City name for a public weather hint', 'JSON text to validate', 'IANA timezone name') and do not apply to parsing a GitHub repo. Only 'url' and possibly 'ref' are plausibly relevant, but their descriptions ('HTTPS URL to normalize or cite' and 'Git ref name; discarded after the shape check') are generic and not GitHub-specific. This is actively misleading.

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

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

The description clearly states the action ('Parse') and the resource ('owner and repo from a GitHub URL'), making the tool's core purpose immediately understandable. However, it does not explicitly differentiate itself from sibling URL-related tools like normalize-url or domain-shape, though the GitHub-specific focus provides some distinction.

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

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

No guidance is given on when to use this tool versus alternatives such as normalize-url or fetch-status. The description implies a parsing task but does not specify expected input formats, whether the URL is required, or what kind of GitHub URLs are supported, leaving the agent to infer usage 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?

Since no annotations are provided, the description carries some behavioral burden. It does reveal that titles are discarded and that the output is a count of current front-page stories. However, it does not clarify whether the tool makes a network request, whether there are rate limits, or what error cases might occur.

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

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

The description is only two short sentences with no filler or redundancy. The primary action is front-loaded and the second sentence adds a meaningful boundary by clarifying that titles are not returned.

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

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

For a tool with 9 optional parameters, no output schema, and no annotations, the description is too sparse. It does not say whether no parameters are needed, whether some parameters should be used, or whether all parameters are effectively ignored. An agent may be able to call it with an empty object, but the tool definition does not make that invocation contract explicit.

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 description coverage is 100%, so the baseline for this dimension is 3. The description adds little beyond the schema: 'Titles discarded' lightly echoes the feed parameter description, but it does not explain how to use any of the 9 optional parameters or why they exist for this tool.

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

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

The description states a specific verb and resource: 'Count current Hacker News front-page stories.' The additional clause 'Titles discarded' clarifies that the tool returns only a count, not story content. It does not explicitly name or distinguish a sibling tool, but the purpose is clear and not just a restatement of the tool name.

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 when-to-use guidance, no when-not-to-use guidance, and no mention of alternative sibling tools. The usage context (e.g., 'use this when you need just the count, not the titles') is only implied by the purpose, not actually stated.

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, permissions, or data handling. It mentions none, and the parameter descriptions about 'discarded' are not part of the tool description itself. The agent cannot infer whether this tool is read-only or has other behaviors.

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

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

The description is one sentence and thus concise, and the parameter descriptions are individually brief. However, the lack of a clear verb and the mismatch between the tool purpose and parameter meanings make the structure feel disjointed, though not overly verbose.

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

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

Given the tool has 9 optional parameters and no output schema, the description is severely incomplete. It does not explain what the tool does with these parameters, what it returns, or how timezone names are selected or filtered. An agent calling this tool would have no idea what to expect.

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

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

While each parameter has a description, they are inconsistent with the tool's stated purpose. For example, 'ref' is a Git ref name and 'url' is for normalizing, which have no apparent connection to IANA timezone names. The descriptions provide some meaning but fail to clarify how these parameters relate to the tool's function, so they add little 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 'Common IANA timezone names for clock calls' is a noun phrase rather than an active verb, so it does not clearly state what action the tool performs or what output it returns. It hints at providing timezone names but leaves the exact behavior 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?

There is no guidance on when to use this tool versus alternatives such as timezone or utc-time. The description does not mention any conditions, prerequisites, or exclusions, leaving the agent without direction on tool 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, the description carries full burden. It discloses that a network fetch occurs, but does not mention failure behavior, rate limits, or that only group counts are returned. No side effects or safety characteristics are addressed.

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 redundant or filler content. It efficiently communicates the core action and expected output.

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

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

The description is not complete enough given the 9-parameter schema. It does not explain which parameters are used, how the target robots.txt is specified, or what the returned group counts represent. No output schema is provided, and the parameter descriptions add confusion rather than clarity.

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 generic and largely irrelevant to fetching robots.txt. For example, 'url' is described as 'HTTPS URL to normalize or cite' rather than a robots.txt URL, and many parameters like 'city' and 'json' appear unrelated to the tool'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 clearly states the verb ('Fetch'), the resource ('a public robots.txt'), and the output ('return group counts only'). It is specific enough to distinguish this from generic fetch tools, though it does not explicitly name sibling alternatives.

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

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

No guidance is provided about when to use this tool versus alternatives like web-fetch, fetch-status, or normalize-url. The description implies robots.txt inspection, but does not state conditions or exclusions.

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

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

With no annotations, the description carries the full burden of disclosure. It states 'Key discarded,' implying non-persistence, but does not describe the return value, error behavior, or any side effects. The parameter descriptions also mention discarding inputs, but the overall transparency is minimal.

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 (two sentences), but brevity without substance is under-specification. It does not front-load the essential information about which parameter to use or what the tool returns, so it fails to be efficiently informative.

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, no annotations, and a vague description, the tool is severely incomplete. An agent cannot determine which input to provide or what the tool will do with it, making correct invocation impossible without external knowledge.

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

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

Schema coverage is 100%, so each parameter has a description, but those descriptions are inconsistent with the tool's stated purpose (e.g., 'City name for a public weather hint'). The tool description does not explain which parameter is the Jira key or how the parameters relate to the shape check, adding 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 verb ('Check') and a resource ('Jira issue key shape'), but it never specifies which of the 9 parameters carries the Jira key. The parameter list includes unrelated fields like city, feed, and json, so the tool's actual purpose is unclear. It also does not differentiate from sibling shape-checking tools like github-repo-shape.

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

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

No guidance is provided on when to use this tool versus any of the many sibling shape-check tools. There is no mention of conditions, alternatives, or exclusions, leaving an agent to guess which tool fits a given input.

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

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

With no annotations, the description carries the full burden. It does disclose that the body is discarded, which is a behavioral detail. However, it says nothing about how the other parameters (city, feed, json, etc.) are handled, whether the tool makes network calls, or what the return value looks like. The disclosure is minimal and incomplete.

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

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

The description is extremely short (one sentence) but lacks structure. It does not front-load the full scope; it only mentions one narrow use case. For a tool with 9 parameters, this is under-specification rather than conciseness. It could be structured to list the main function and then note that it handles multiple input types.

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

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

Given the tool has 9 parameters, no annotations, and no output schema, the description is grossly incomplete. An agent cannot infer what the tool does for parameters like city, feed, json, path, zone, or query. The description only covers the URL case, leaving the rest ambiguous. It fails to explain the tool's actual behavior or how 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?

Schema coverage is 100%, so the baseline is 3. The description adds nothing beyond the schema's per-parameter descriptions. It doesn't clarify how parameters interact or which are used for the stated purpose. Since the schema is self-sufficient, the description doesn't need to repeat it, but it also fails to add any semantic context.

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

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

The description states a specific verb and resource: 'HTTP status for a public library docs URL.' However, it is extremely narrow and does not reflect the schema's 9 parameters covering city, feed, json, path, zone, query, etc. This suggests the tool may have broader functionality or the description is misleading. It also fails to differentiate 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 guidance is given on when to use this tool versus the many similar siblings (fetch-status, browser-url-ok, playwright-url-ok, normalize-url). It doesn't state any conditions or exclusions, leaving the agent to guess the appropriate 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states 'Values discarded,' which is a vague behavioral note. It does not mention the return value (presumably a count), whether the operation is read-only, or what happens with the other parameters. The lack of clarity about which input is the JSON object makes the 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 brief, but it is under-specified rather than concise. The brevity omits essential information about how to use the tool and what it returns, making it ineffective for an agent.

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

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

With 9 parameters, no output schema, and no annotations, the description must explain the tool's purpose, input, and output. It fails to do so, providing only a minimal statement that does not cover the tool's operation or the role of most parameters. The agent cannot determine the 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. However, the tool description only mentions JSON object counting, while the schema lists many unrelated parameters (ref, url, city, etc.). The description does not connect the JSON object to a specific parameter, leaving the agent uncertain which one to provide. It adds no semantic value beyond the schema and actually creates confusion.

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

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

The description states a verb (count) and a resource (keys in a JSON object), but it does not specify which parameter provides that JSON object. The tool name suggests memory counting, yet the description does not clarify the relationship to the 'json' parameter or any stored memory. It also does not distinguish this tool from siblings like validate-json 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?

No guidance is provided on when to use this tool versus alternatives. There is no mention of conditions, prerequisites, or exclusions, and the 9 optional parameters leave the agent without any hint about the intended use case.

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, but it only states the output and that query/fragment are dropped. It does not disclose whether the URL is fetched, whether only the 'url' parameter is used, or what happens with invalid/missing input.

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

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

Two short sentences with no filler. The primary purpose is front-loaded and the query/fragment behavior is stated efficiently.

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

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

Despite 9 optional parameters, the description does not explain which parameter supplies the URL, what the output shape is, or how the extraneous parameters relate to the tool. An agent could guess 'url', but the definition is incomplete for reliable invocation.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no meaningful parameter-level meaning beyond the schema; it does not clarify that the many optional parameters are ignored or that only 'url' should be passed.

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

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

The description states a specific verb and resource: 'Return origin, host, and path for a URL' and clearly scopes the behavior by dropping query and fragment. This is enough for an agent to know what the tool does.

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

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

No explicit guidance on when to use this tool versus sibling URL tools such as web-fetch, fetch-status, or browser-url-ok. The only implicit hint is that query/fragment are dropped, but it does not say when to choose an alternative.

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 and only discloses that no browser is launched. It does not state whether a network request is made, what side effects occur, what 'opened' means, or what the return value/error behavior is.

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

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

The description is a single, front-loaded sentence with no redundant words. It delivers the core action and an important behavioral caveat efficiently.

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

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

Despite the short description, the context is incomplete: there is no output schema, no required parameters, and no explanation of how to invoke the check among nine optional inputs. The schema and description leave too many gaps for reliable use.

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

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

Every parameter has a schema description, but those descriptions (e.g., 'Git ref name; discarded after the shape check', 'City name for a public weather hint') are inconsistent with the URL-checking purpose and the tool description adds no relationship between the nine optional parameters. The agent is left unsure which fields are relevant or how they combine.

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

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

The description states a clear action ('check whether a URL can be opened') and a constraint ('No browser is launched'), but 'can be opened' is ambiguous and the 9-property schema includes many unrelated fields (ref, city, feed, json, zone, query) that are not explained by this purpose. As a result, an agent cannot confidently determine what this tool actually does.

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

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

There is no guidance about when to use this tool instead of closely related siblings such as browser-url-ok, fetch-status, normalize-url, or domain-shape. The only hint is 'No browser is launched,' which is not enough to select between alternatives.

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

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

The description does disclose that the query is discarded, which is a useful side-effect warning. However, it does not clarify that all other parameters are likely ignored or that no other I/O occurs, leaving the behavioral contract incomplete given no annotations.

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

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

The description is extremely concise: two short sentences, no redundant fluff, and the key action is front-loaded. Every word contributes useful information.

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

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

Given nine optional parameters and no output schema, the description is too sparse. It does not specify the return value, how characters are counted (e.g., code points vs. UTF-16 units), what happens when query is omitted, or that non-query parameters are irrelevant.

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

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

The input schema already describes every parameter, so the baseline is 3. The top-level description adds no extra meaning about how the many additional parameters relate to the tool, and some schema descriptions (e.g., URL normalize/cite) seem unrelated to character counting.

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 specific action: counting characters in a search query. It is distinct from sibling tools like memory-key-count or think-steps.

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

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

The description implies when to use the tool (when you need the character length of a search query), but it does not explicitly compare against alternatives or state when not to use it. No exclusions or alternative tool references are provided.

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

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

The description does not disclose what the tool does with its inputs. While some parameter descriptions mention 'discarded' or 'no disk access', the overall behavior (e.g., whether it returns a list, filters, or performs validation) is not described. No annotations exist to supplement this.

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 and is brief, but it lacks structure and fails to convey useful information. While concise in length, it does not effectively communicate the tool's function or any related details, so it earns a middle score.

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

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

Given the tool's complexity (9 optional parameters, no output schema), the description is severely incomplete. It does not explain how parameters relate to the catalog, what the return format is, or any constraints. A user cannot confidently call this tool without additional 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?

Each parameter has a description, but these descriptions are not connected to the tool's stated purpose. For example, 'Git ref name; discarded after the shape check' implies a validation step, but what shape check? The descriptions do not clarify how any parameter affects the HTTP status code catalog, making them unhelpful for selecting appropriate inputs.

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

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

The description states a resource ('short catalog of common HTTP status codes') but does not explain how the nine input parameters relate to that resource. The parameters (ref, url, city, feed, host, json, path, zone, query) appear unrelated to HTTP status codes, making the tool's actual purpose ambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives. With sibling tools like fetch-status and browser-url-ok, a user cannot determine if this tool is for looking up status codes, validating URLs, or something else entirely.

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

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

There are no annotations, so the description carries the full transparency burden. It discloses that the prompt is discarded and several inputs are 'discarded after' checks, but it does not describe the return format, error behavior, side effects, or why the nine parameters are accepted.

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

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

The description is extremely short and front-loaded with the main action. Every sentence contributes, and there is no filler. It loses a point because 'Prompt discarded' is a fragment and could be clearer as a full sentence.

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

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

With nine parameters, no output schema, no annotations, and no explanation of the tool's role, the two-sentence description is far from complete. It does not describe what the three-step template looks like, how it should be used, or what happens with the 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?

The schema has 100% description coverage, but most parameter descriptions are unhelpful or confusing, e.g., 'discarded after the shape check.' Some descriptions label the value type ('HTTPS URL', 'IANA timezone name'), but none explain the actual role of the parameter in producing the returned template or why it exists.

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

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

The description names a concrete action and object: 'Return a three-step thinking template.' This is not a tautology and is somewhat clear. However, the phrase 'Prompt discarded' is ambiguous and does not explain what the template contains or why it should be used, and it doesn't distinguish the tool from the many sibling validation tools.

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

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

No guidance is given for when to call this tool versus any sibling tool. The only behavioral note is 'Prompt discarded,' which warns against relying on the prompt but does not explain use cases, prerequisites, or alternatives.

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

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

The description only states the output concept; it does not say whether the operation is read-only, what happens with invalid zone names, or whether non-zone parameters are ignored. Since annotations are absent, this leaves behavioral questions unanswered.

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

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

The description is a single, front-loaded sentence that is easy to scan. It is concise, though it sacrifices detail needed to handle the noisy schema.

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

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

With nine parameters and no output schema, the single-sentence description leaves the agent to guess which parameter is meaningful and what the response looks like. The schema descriptions help for individual fields but not the overall call contract.

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 each parameter has a description, most have no stated connection to timezone; only zone is explicitly tied to the tool's purpose. The description does not clarify how to treat ref, url, city, feed, host, json, path, or query, so the parameter semantics are confusing.

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

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

The description explicitly names the resource (IANA timezone) and result (current time), so the core purpose is clear. It is not phrased as an imperative, and the many unrelated schema parameters add noise, but the intended function remains identifiable.

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 or when-not-to-use guidance is provided. The agent must infer from the name that this is for IANA timezone lookups; alternatives like utc-time or iana-zones are not addressed.

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

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

There are no annotations and the description discloses no behavioral details. It does not mention side effects, permissions, or what happens with the input parameters, which are numerous and appear unrelated to a UTC timestamp.

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 (one sentence), but it is too sparse to be useful. The structure provides no hierarchy or additional detail, and while short, it fails to convey essential information.

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

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

There is no output schema, no example, and no explanation of return values. Given the tool has 9 unnecessary-looking parameters and no stated output, the description is incomplete for an agent 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?

The schema lists 9 parameters, each with a description, but those descriptions are generic or irrelevant to a UTC timestamp tool (e.g., 'Git ref name', 'HTTPS URL', 'City name'). The tool description adds no meaning to bridge the gap, making the parameters effectively meaningless.

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.' is a bare statement without a verb or scope. It does not differentiate the tool from sibling tools like 'timezone' or 'iana-zones', nor does it clarify what action is performed (e.g., fetch, format, convert).

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

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

No guidance is provided on when to use this tool versus alternatives. The description lacks any context for selecting it over timezone-related siblings or other utilities.

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

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

The only behavioral note is that the body is discarded, which hints at read-only behavior. There are no annotations, and the description omits side effects, errors, return behavior, or any network/storage 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 very short, but the brevity sacrifices clarity: an undefined 'body' term appears, and the relationship to the schema's nine parameters is left unexplained. It is concise in word count but not in effective communication.

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

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

With no output schema, no mention of the return value or error behavior, and no explanation of which parameter actually holds the JSON, the description is incomplete for an agent to confidently invoke the tool.

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

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

While the schema provides descriptions for all parameters, the tool description introduces 'body' and does not map it to the 'json' parameter. The many unrelated-looking optional parameters are not tied to the tool's stated purpose, so the description adds no useful semantics and creates confusion.

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

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

The description states a purpose ('Check whether a body is valid JSON') but uses 'body', a term that does not appear in the schema, and never identifies that the 'json' parameter is the actual JSON input. The purpose is recognizable but 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 about when to choose this tool over the many sibling validation/shape-checking tools, no conditions are specified, and no alternatives are mentioned.

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

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

With no annotations present, the description must convey behavioral traits itself. It does not mention network access, side effects, output format, or the fact that most schema fields are discarded, so the agent is left without important behavioral context.

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

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

The description is a single, compact sentence that leads with the core purpose and includes the data source. There is no fluff or redundant detail.

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

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

Given the schema contains nine optional and mostly unrelated parameters, the description does not clarify which are needed or how they are handled. It also omits the expected output and what happens when the relevant city parameter is missing.

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

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

The schema already provides descriptions for all parameters, so the description need not repeat them. However, the description adds no extra meaning about how the non-city parameters relate to the tool's behavior, keeping this at the baseline for high schema coverage.

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

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

The description clearly identifies the tool's function as returning the current temperature for a city using Open-Meteo. It is specific enough to distinguish it from most sibling tools, though it is phrased as a noun fragment rather than an explicit action.

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

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

The description provides no guidance on when to use this tool versus alternatives or when not to use it. It only states what it does, leaving the agent to infer the appropriate context.

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

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

With no annotations, the description carries the full burden. It discloses that the body is discarded, which is a useful behavioral detail, and implies read-only access by stating 'public URL'. However, it does not mention error behavior, rate limits, or what happens with non-URL parameters, leaving gaps for an agent to discover.

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

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

The description is a single, front-loaded sentence that efficiently conveys the primary function and a key limitation. It wastes no words and places the core action first. This is an exemplary level of 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?

Despite the 100% schema coverage, the tool has 9 parameters and no output schema, and the description is too narrow to cover its actual behavior. The description mentions only 'HTTP status and content type' but the parameters include city, zone, json, path, etc., which are not URLs. This mismatch leaves an agent unsure about the full scope and return format. The description should clarify that these parameters are discarded or that the tool serves multiple purposes.

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

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

Schema description coverage is 100%, so the schema already documents all 9 parameters. The description adds no additional meaning about how parameters relate to the tool's purpose, nor does it clarify that many parameters (like city, zone, json) seem unrelated to the stated 'public URL' function. Baseline 3 applies since the schema does the heavy lifting.

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

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

The description clearly states the verb (fetch) and resource (public URL), and specifies the outcome (HTTP status and content type). It is specific enough to understand the core function, but it does not explicitly differentiate from sibling tools like fetch-status or normalize-url, so it loses a point.

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 scenarios where this tool is preferred over fetch-status, browser-url-ok, or normalize-url, nor does it state any exclusions. The only implicit hint is the emphasis on 'public URL' and discarding the body, but no explicit routing 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 provided, the description carries the full burden of behavioral disclosure. It only notes that the title is discarded after the call, but does not state whether it performs a network request, whether it is read-only, what it returns (e.g., boolean), or any side effects. This is minimal and insufficient.

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 fluff, and it front-loads the core purpose. It is concise and easy to parse. However, it omits essential information that a longer description could have included, so it earns a 4 rather than a 5.

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

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

For a tool with 9 parameters, no annotations, and no output schema, the description is severely incomplete. It does not explain how to invoke the tool (which parameter holds the title), what the expected output is, or any constraints (e.g., network dependency). The description leaves too much to inference, making it inadequate for an agent to call correctly.

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

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

The description does not clarify which parameter corresponds to the Wikipedia title, despite the schema having 9 optional parameters with vague descriptions like 'Git ref name; discarded after the shape check' and 'Search text; discarded after the length check'. Although schema coverage is 100%, the parameter descriptions are unrelated to the tool's stated purpose, and the description adds no meaning to bridge the gap.

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

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

The description states a clear verb and resource: 'Check whether a Wikipedia title exists.' This is specific and distinguishes the tool from siblings like 'browser-url-ok' or 'normalize-url'. However, the schema lacks a parameter for the title, which could confuse an agent about how to provide it, so it's not a perfect 5.

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

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

No guidance on when to use this tool versus alternatives. It does not mention scenarios, exclusions, or sibling tools. The description is a single statement of purpose with no usage context.

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