America/Lima clock

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

The description mentions that task text is discarded and that it returns connection methods, but it does not clarify side effects, such as whether external calls are made or if costs are incurred. The 'pay-per-call' hint is vague and not elaborated. 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 concise, consisting of two sentences. However, the large and largely irrelevant schema is not structurally integrated with the description, and the tool's actual input mechanism is unclear. This balance of brevity and clarity is acceptable but not highly effective.

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

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

The description lacks essential context: there is no output schema, no examples, no explanation of how the gateway is returned, and no error handling information. Given the tool's apparent purpose and the ambiguous parameters, the provided information is insufficient for an agent to confidently invoke it.

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

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

All 9 parameters are optional and have descriptions that explicitly state they are discarded (e.g., 'discarded after the shape check'). This indicates the parameters do not functionally contribute to the tool's outcome, yet no alternative parameter (like a 'task' field) is provided to specify the requested task, making the input schema misleading and unhelpful.

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: to find a public pay-per-call gateway for tasks like weather, search, scrape, or voice. The verb 'find' and the examples make it specific, though it does not explicitly differentiate from sibling tools, so a perfect score is not given.

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 or contexts that would favor this tool over siblings, leaving the agent without any decision support.

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 does not disclose return values, side effects, error behavior, or whether the tool performs network requests. The schema's 'discarded after' notes hint at ignored inputs, but this is not explained in the tool description.

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

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

The description is very concise and front-loaded with the main purpose. The schema is verbose but not part of the prose description; no wasted sentences appear in the description itself.

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 definition lacks output schema, return value description, usage examples, and edge-case handling. Given the confusing parameter list and sibling tools, the description is not complete enough for an agent to understand expected behavior or 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?

Although schema coverage is 100%, many parameter descriptions are unrelated or misleading, such as 'Git ref name' for ref, 'City name' for city, and 'IANA timezone name' for zone. Only url, host, path, and query loosely align with the stated purpose of checking a URL.

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

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

The description states a clear action and object: 'Check whether a URL can be opened' and clarifies that no browser is launched. However, the input schema contains many unrelated parameters (city, feed, json, zone) that obscure the tool's actual purpose.

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

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

The description does not indicate when to use this tool versus alternatives like playwright-url-ok, web-fetch, or normalize-url. The only guidance is the negative constraint 'No browser is launched,' which is insufficient for selecting among sibling tools.

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

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

The phrase 'Expression discarded' hints at a stateless evaluation, but there is no explanation of side effects, return values, error behavior, or what 'discarded' means. Since no annotations are provided, the description carries full responsibility and does not sufficiently disclose behavior.

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

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

The description is short but not effective; the single sentence introduces a purpose contradicted by the schema and omits essential operational details. Brevity is not helpful when it leaves the reader unable to determine valid inputs or expected outputs.

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 only mentions arithmetic evaluation and discarding the expression. It does not explain how the listed parameters relate to the operation, what the tool returns, or when it should be invoked.

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, those descriptions are inconsistent with the stated arithmetic purpose and with each other (e.g., 'Git ref name', 'HTTPS URL to normalize or cite', 'City name for a public weather hint'). They add confusion rather than meaning, especially with no expression parameter present.

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 'Evaluate a+b style arithmetic' but none of the schema parameters represent an expression; parameters are unrelated strings like url, city, host, json, path, zone, query. This is misleading rather than clarifying the tool's actual purpose, and it does not distinguish it from the many sibling validation/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?

No guidance is given about when to use this tool versus the many sibling tools such as fetch-status, validate-json, normalize-url, or search-query-len. The description and parameter names imply a grab-bag of different checks with no criteria 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?

The description adds one meaningful behavioral trait: 'Page content is not stored,' which is useful for a URL-fetching tool. However, it does not disclose whether the tool makes a network request, follows redirects, requires auth, or handles invalid URLs. With no annotations, the description carries the full burden and only partially meets it.

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

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

The description is two short sentences with no filler. The core action is front-loaded, and the privacy note earns its place. It is appropriately concise.

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

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

The tool has 9 optional parameters and no output schema, yet the description only addresses the URL case and does not explain how the other parameters (city, feed, json, path, zone, query) relate to the tool. It also does not specify the return format or whether non-URL parameters are ignored. This leaves an agent uncertain about correct invocation for anything beyond a simple URL.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level detail beyond the schema; it only mentions 'a URL,' while the schema already documents each parameter, including discard behavior. It does not clarify which of the 9 optional parameters should be used together.

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') and resource ('a URL'), so an agent knows the core function. However, it does not differentiate from siblings like fetch-status or normalize-url, and the name 'citation' is not explained. The presence of 9 unrelated parameters in the schema further 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?

No guidance is given about when to use this tool versus alternatives such as fetch-status, normalize-url, or browser-url-ok. There are no conditions, exclusions, or context cues. The description only states what it does, not when it should be chosen.

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 no output schema, the description carries the full burden but only says identifiers are not retained. It does not disclose what output is produced, whether side effects occur, or how input is processed.

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

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

The description is brief and not wordy, but it is too sparse to be useful. It fits within one sentence, yet that sentence lacks the detail needed to understand the tool.

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 required fields, and no output schema, but the description does not explain how many parameters to supply, what output to expect, or how 'compatibility' is determined. This makes the tool effectively unusable from 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?

All 9 parameters have individual descriptions with examples of expected formats, so schema coverage is complete. However, because the tool's purpose is unclear, the relationship between these parameters and the classification behavior is not explained.

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

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

The description says 'Show how this request is classified' but never defines what classification means or what resource/action is involved. The generic name 'compatibility' and the lack of a clear object make the 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 for when to use this tool instead of a sibling validator, nor any conditions or alternatives. The description does not mention the other tools or specify input criteria.

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

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

With no annotations, the description carries the full burden, but it only reveals the basic action and a single non-goal. It does not describe behavior for invalid input, how irrelevant parameters are treated, or what a typical response contains.

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

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

The description is a single, compact sentence with no filler or redundancy. It front-loads the action and object while adding a useful exclusion, making it highly concise.

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

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

The tool has nine optional parameters and no output schema, but the description does not clarify how parameters map to the operation, which are ignored, or what a successful result looks like. This leaves too much ambiguity for confident 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?

Although schema descriptions cover all parameters, most are unrelated to splitting a hostname (e.g., git ref, city, RSS feed, JSON) and appear generic or mismatched. Only 'host' aligns clearly with the tool purpose, and no parameter is identified as the primary input.

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

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

The description clearly identifies the action as splitting a hostname into labels and explicitly excludes WHOIS or ownership data. It does not mention output format, but the core purpose is understandable.

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

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

The description gives no guidance on when to choose this tool over siblings like normalize-url or fetch-status. It also does not explain which of the nine optional parameters should be supplied or how the tool should be invoked.

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

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

Without annotations, the description must disclose side effects. It states 'return status only,' which is transparent about output, but it does not clarify whether the extra parameters are ignored, whether the HEAD request follows redirects, or any network/rate-limit consequences. The short description fails to fully inform the agent about the tool's actual behavior.

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

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

The description is very brief—one sentence—which is concise, but it omits essential details about the parameter handling and tool scope. The structure is adequate for a simple tool, but the lack of clarity about the extra parameters makes it feel incomplete rather than efficiently succinct.

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 far too minimal. It does not explain the purpose of the 8 extraneous parameters, does not clarify that only 'url' is relevant, and provides no output schema or examples. The agent is left with a misleading impression that all parameters have meaningful roles, leading to potential misuse.

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 explain any parameter, and the schema descriptions are wildly inconsistent (e.g., 'ref' says 'Git ref name; discarded after the shape check' and 'query' says 'Search text; discarded after the length check'), which are unrelated to a URL HEAD request. The agent cannot determine which parameter is actually used or how to pass the URL correctly.

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 return behavior ('status only'), but the schema includes 8 unrelated parameters (ref, city, feed, host, json, path, zone, query) with nonsensical descriptions, creating ambiguity about the tool's true purpose and 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 provided on when to use this tool versus siblings like browser-url-ok, web-fetch, or normalize-url. There is no mention of prerequisites, limitations, or alternative scenarios, leaving the agent without direction for 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?

No annotations are present, and the description only mentions that the path is discarded. It does not disclose whether the tool is read-only, makes network calls, or has side effects, leaving behavior largely opaque.

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

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

The description is extremely brief (one sentence), which is concise but lacks necessary structure. It does not outline the input or output format, leaving the tool under-specified for an agent to use effectively.

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

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

There is no output schema or explanation of what the tool returns. Given the tool's narrow purpose (parsing a Figma URL), the lack of output details makes it incomplete for an agent to understand the result.

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

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

The schema lists 9 parameters with descriptions that are generic and mostly unrelated to Figma URL parsing (e.g., 'Git ref name', 'City name for a public weather hint'). The 'url' parameter is loosely relevant, but the others are misleading, and the description does not clarify which 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 ('Parse a Figma file URL') and resource, but it is vague about what parsing entails or what output is produced. The 'Path discarded' hint adds some clarity but leaves the overall purpose underdefined.

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 similar siblings (e.g., normalize-url, fetch-status). There is no mention of prerequisites, alternatives, or typical use cases.

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

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

The description explicitly states 'No disk access,' which is a meaningful transparency note about a side effect (or lack thereof). However, it does not disclose whether the tool performs any other operations (e.g., network calls, file reads) or if there are any side effects on the system. Given the absence of annotations, this partial disclosure is helpful but not comprehensive.

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, using two short sentences that convey the core purpose and a key limitation (no disk access). It is well-structured and easy to read. However, it omits critical information about parameter usage, but this does not detract from its succinctness.

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

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

The description is incomplete for a tool with such a complex schema. It does not explain why unrelated parameters are present, nor does it specify the expected input format for the 'path' parameter or the output/return value. The lack of clarity about the tool's actual scope makes it difficult for an agent to use correctly without additional outside 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?

The schema provides descriptions for all 9 parameters, achieving 100% coverage, but many of those parameters (url, city, feed, host, json, zone, query) are unrelated to checking a file path. The tool description does not clarify which parameters are relevant or how they are used, leaving the agent to guess. The parameter descriptions themselves are generic and do not clarify their role in the 'path safety' check.

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

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

The description clearly states the action (check whether a path looks safe) and that no disk access is performed. However, the schema includes 9 unrelated parameters (e.g., url, city, feed, host, json, zone, query) making it ambiguous which parameter is actually used for the path check. The description does not specify that 'path' is the relevant parameter, reducing clarity for the agent.

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 alternative sibling tools (e.g., browser-url-ok, domain-shape, normalize-url). No prerequisites, limitations, or typical use cases are mentioned. The agent is left without context to decide if this tool is appropriate for a given task.

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

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

With no annotations provided, the description carries the full burden. It reveals the basic output (coordinates) and external service (Open-Meteo), but omits behavior around parameter handling, side effects, failures, and output format.

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

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

The description is brief and free of fluff, but it is a noun phrase rather than a complete sentence and is too sparse to be considered well-structured for a tool with nine parameters.

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

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

Given the complex schema with nine optional parameters and no output schema, the description is far from complete. It lacks parameter mapping, usage examples, output details, and error behavior.

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

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

Although every parameter has a schema description, many descriptions are confusing or unrelated to geocoding (e.g., 'Git ref name; discarded after the shape check', 'JSON text to validate; discarded after the check'). The tool description does not explain how any of the nine optional parameters maps to a place lookup.

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

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

The description clearly states that the tool returns latitude and longitude for a place via Open-Meteo, but it lacks an explicit verb and does not explicitly distinguish it from sibling tools such as weather-hint.

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

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

There is no guidance on when to use this tool versus alternatives, no mention of expected inputs, and no context about which parameter represents the 'place'.

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 output format, error behavior, or whether the operation is purely read-only. 'Parse' implies no side effects, but this is not explicit.

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

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

The description is concise and easy to understand, but the input schema contains many extraneous optional fields that add noise to an otherwise simple tool definition.

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 lacks an output schema and does not describe its return value, success criteria, or invalid-input handling. An agent cannot fully predict the result of invoking this tool.

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

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

Although schema descriptions cover 100% of parameters, many included parameters (city, feed, json, query, etc.) are unrelated to parsing a GitHub URL. The url parameter description is generic and does not specify it should be a GitHub URL, and no parameter is marked required.

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 and specifically states the tool's purpose: parsing owner and repo from a GitHub URL. This is distinguishable from related URL/shape 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 explain when to use this tool versus alternatives such as normalize-url or other URL validators, nor does it provide usage context or examples.

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 provides little behavioral detail. It does not mention whether the tool performs network access, whether it is read-only, what it returns, or how it handles the nine optional parameters beyond the vague 'discarded' hints.

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

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

The description is very short and to the point, with no filler. The second sentence 'Titles discarded' is a minor distraction but does not significantly harm readability.

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

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

The description lacks essential context: no indication of what the output looks like, no explanation of the nine optional parameters, and no guidance on required versus optional inputs. The tool is not usable as described because the parameter set appears mismatched with the stated purpose.

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 descriptions for all nine parameters, those descriptions are unrelated to counting Hacker News stories (e.g., 'Git ref name', 'City name for a public weather hint', 'IANA timezone name'). The tool description does not explain how any of these parameters affect the count, making them effectively meaningless in 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 clear action and target: count current Hacker News front-page stories. The phrase 'Titles discarded' is slightly ambiguous but does not obscure the primary purpose. It is distinguishable from sibling tools by its specific focus on counting HN front-page items.

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 explain when to use this tool versus alternatives like web-fetch or fetch-status. It gives no conditions, exclusions, or context about when counting HN front-page stories would be the appropriate choice.

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

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

No annotations are provided, and the description does not disclose whether the tool is read-only, what it returns, whether parameters are ignored, or what side effects (if any) occur. The description offers no behavioral detail beyond the vague 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 sentence with no redundancy, so it is concise and front-loaded. However, it is too sparse and omits essential action and usage details, making the conciseness more a symptom of incompleteness than effective brevity.

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 return-type information, and no usage context. The description does not explain what the tool actually produces or how the listed parameters should be provided, so an agent cannot confidently invoke it.

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

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

Although every parameter has a schema description, most of those descriptions are unrelated to the stated purpose (e.g., Git ref, URL, JSON, city weather). The only clearly relevant parameter is 'zone', but the description does not explain how it relates to the other eight optional parameters or how the tool uses them.

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

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

The description identifies the domain ('IANA timezone names') and intended use ('for clock calls'), but it lacks a verb or explicit action. It is unclear whether the tool lists, validates, normalizes, or retrieves timezone names, and it only weakly distinguishes itself from sibling timezone 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 provides no guidance on when to use this tool versus alternatives such as timezone, tz-america-lima, or utc-time. There is no mention of preferred scenarios, prerequisites, or excluded cases.

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

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

No annotations are provided, so the description must carry the full burden. It implies a network fetch and a counts-only output, but does not disclose error behavior, rate limits, or what happens if the robots.txt is missing or unreachable. It also fails to specify which input parameter is actually used for the fetch, despite the schema listing nine parameters.

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

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

The description is a single concise sentence, which is good for scannability. However, it omits essential information about parameter usage and behavior, making it under-specified rather than appropriately concise.

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

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

Given the tool has nine parameters and no output schema, the description is incomplete. It does not explain how to map parameters to the fetch, what constitutes 'group counts', or how errors are handled. An agent would struggle to call this correctly without external knowledge.

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

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

Although schema coverage is 100%, the parameter descriptions are generic and not tied to the tool's purpose. For example, 'url' is described as 'HTTPS URL to normalize or cite' rather than as the target for robots.txt. The tool description does not clarify which parameter is relevant or how parameters like 'ref' or 'city' fit into the operation, so the description adds little value over the schema.

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

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

The description states a specific action ('Fetch a public robots.txt') and output ('return group counts only'), which is clear and distinguishes it from generic fetch tools. However, it does not explicitly differentiate it from sibling tools like 'fetch-status' or 'web-fetch', leaving some ambiguity about when this specific tool is preferred.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention conditions, prerequisites, or exclusions. An agent would not know whether to pick this over 'fetch-status' or 'domain-shape' without further 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?

The description says 'Key discarded' and some schema fields mention 'discarded after the check', implying no persistence, but it does not clarify side effects, return format, or whether any network/disk access occurs. With no annotations, this leaves important behavioral details undisclosed.

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 brief and free of fluff, which is good for conciseness, but it omits essential information about input expectations. It is structurally simple but not sufficiently informative for a usable tool description.

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

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

Given the confusing schema and lack of output schema, the description is far from complete. It does not explain how to pass the Jira key, what a valid key looks like, whether the tool returns a boolean or error, or how it differs from the numerous sibling validation tools.

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

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

The schema contains nine generic parameters (ref, url, city, feed, host, json, path, zone, query) with descriptions unrelated to a Jira key shape check. There is no parameter clearly designated as the Jira key, and the descriptions add no useful mapping to the tool's purpose. This is severely misleading.

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

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

The description states the tool checks a Jira issue key shape, which conveys a general validation purpose, but it does not specify what constitutes a valid shape (e.g., 'PROJ-123') or what the tool returns. It is clearer than a pure tautology but leaves key semantics 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 versus sibling shape/length checkers like 'github-repo-shape', 'domain-shape', or 'search-query-len'. No conditions, examples, or alternative selection criteria 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 discloses that the body is discarded, but with no annotations it does not explicitly state whether a network request is made, redirects are followed, or any other side effects occur.

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

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

The description is extremely concise, front-loaded, and contains no redundant or filler content.

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 leaves critical gaps: it does not identify the relevant parameter, specify the return format, or describe behavior on errors/redirects, and there is no output schema to fill this in.

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, most are unrelated to the stated purpose (city, feed, json, zone, etc.), and the url description mentions normalization/citation rather than HTTP status checking; with no required parameters it is unclear which input actually drives the 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 the tool returns an HTTP status for a public library docs URL and discards the body, clearly conveying the core purpose despite lacking an explicit verb.

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 sibling tools such as fetch-status or browser-url-ok, and no conditions or prerequisites 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?

No annotations are provided, so the description carries the full burden. It mentions that values are discarded, but it does not disclose which parameter is used, what output is returned, whether network or disk access occurs for certain parameters, or how errors are handled.

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

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

The description is extremely concise and front-loaded, consisting of one clear sentence with no fluff. However, the brevity comes at the cost of specifying which parameter is relevant, though that issue is more about completeness than conciseness.

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

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

Given the tool has nine optional parameters and no output schema, the description is far too thin to be usable. It does not explain the relationship between the parameters and the JSON object, the expected output format, or the behavior when multiple parameters are provided.

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, those descriptions are misleading relative to the tool purpose. The 'json' parameter says 'validate', not 'count keys', and many other parameters (ref, url, city, feed, host, path, zone, query) appear unrelated to counting keys in a JSON object. No parameter is clearly designated as the JSON input.

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

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

The description states 'Count keys in a JSON object' at a high level, but it does not identify which of the nine parameters contains the JSON object. The 'json' parameter is described as 'JSON text to validate', which conflicts with the tool's stated purpose of counting keys, making the actual usage 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 like 'validate-json' or other sibling tools. The description and schema provide no selection criteria, prerequisites, or examples of appropriate 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 must disclose all behavioral details. It mentions dropping query and fragment, which is useful, but it doesn't explain how the other 8 parameters are handled. The schema descriptions say they are 'discarded' after some check, but the tool description doesn't reconcile this with its stated URL-only purpose, leaving the agent uncertain about parameter interactions.

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, focused sentence that states the core behavior upfront. Every word adds value, and there is 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?

Despite being a simple operation conceptually, the tool has 9 optional parameters and no required ones, and there is no output schema. The description only covers the URL behavior and ignores the other parameters entirely. An agent is left unsure about what happens if multiple parameters are provided or whether the other parameters are even relevant. This incompleteness could lead to incorrect 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 descriptions cover 100% of parameters with clear text, including notes on which ones are discarded. The tool description itself adds no parameter-level information, so it relies on the schema. Since schema coverage is high, a baseline of 3 is appropriate.

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

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

The description clearly states the tool returns origin, host, and path for a URL, and drops query and fragment. This is specific and unambiguous. However, it doesn't differentiate from sibling tools like 'domain-shape' or 'browser-url-ok' that might have overlapping 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?

The description gives no guidance on when to use this tool versus alternatives. It doesn't mention any context, exclusions, or conditions. The list of sibling tools includes many URL-related tools, and there's no indication of when normalize-url is the preferred 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?

Mentions that no browser is launched, which is a behavioral detail. However, it does not disclose other potential side effects, errors, or assumptions about network access or URL validity.

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

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

The description is extremely concise, using two short sentences without redundancy or unnecessary detail. It gets to the point immediately.

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

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

The description omits essential context about how to map parameters to the intended behavior, and the presence of unrelated parameters suggests the description may be generic or mismatched. An agent would struggle 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 description only references 'a URL' but the schema includes 9 diverse parameters (e.g., city, zone, query) with no explanation of how they relate to the tool's function. This creates confusion and fails to clarify which parameter corresponds to the 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 clearly states the action (check) and the object (URL), and adds that no browser is launched. It is straightforward but does not explicitly differentiate from sibling tools like browser-url-ok or fetch-status.

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

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

No explicit guidance on when to use this tool versus alternatives. The 'no browser launched' hint implies a lightweight check, but it does not state scenarios 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 includes a transparency note ('Query discarded'), which indicates that the input is not stored. However, no other side effects or state changes are mentioned. Since annotations are absent, this brief note partially carries the transparency burden but 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 concise, consisting of one sentence and a short note. Every word serves a purpose, with no redundancy or unnecessary detail.

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

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

The description lacks essential context: it does not specify the return value (e.g., an integer count) or any error/edge-case behavior. Given that there is no output schema, the description should clarify what the tool returns, but it does not. It also omits any usage context relative to the sibling tools.

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

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

The schema covers 100% of parameters with descriptive comments (e.g., 'Search text; discarded after the length check'). The tool description adds no extra semantic layer beyond these per-parameter descriptions, so the baseline score of 3 applies.

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

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

The description clearly states the specific action ('Count characters') and the resource ('a search query'). It is easily differentiated from sibling tools like memory-key-count and hn-front-count, which target different resources.

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 simply states what it does without any conditions, prerequisites, or comparisons to sibling tools.

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

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

There are no annotations and the description does not disclose behavior such as whether parameters are ignored, whether network access occurs, or whether the result is purely static. The schema hints at discarded inputs, but the tool description itself is silent.

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

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

The description is one short, front-loaded sentence with no fluff, but it is too sparse to convey meaningful structure or usage 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 no output schema, no annotations, and only a one-line description, the tool lacks essential context about return values, parameter usage, and expected behavior.

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

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

Although schema descriptions cover 100% of parameters, they are semantically inconsistent with the tool purpose: ref, url, city, feed, host, json, path, zone, and query are unrelated to a status-code catalog and several are explicitly discarded. The tool description adds no clarification.

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 the tool provides a short catalog of common HTTP status codes, but it does not detail output format or how this differs from sibling tools like fetch-status or 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 guidance is provided about when to use this tool vs alternatives, and no context is given for selecting status-catalog over related status or fetch 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?

There are no annotations describing side effects, read-only behavior, or failure modes. The description mentions that a prompt is discarded and that several parameters are discarded after checks, which hints at non-use of inputs, but this is vague and does not clearly disclose the tool's actual behavior.

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

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

The description is extremely short, but the input schema is padded with nine unrelated optional parameters. This creates a contradictory and bloated structure that is neither concise nor helpful for an agent trying to understand the tool.

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, no explanation of the returned template, and no indication of what the parameters do. Given the tool's ambiguous name and mismatched parameters, the context provided is far too incomplete for reliable agent 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?

Although the schema describes each parameter, the descriptions are copied from unrelated domains (URLs, timezones, JSON validation, file paths) and do not explain how any of them relate to returning a three-step thinking template. Most are explicitly marked as discarded, so their semantic contribution is effectively zero.

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 the tool returns a three-step thinking template, which gives some indication of purpose, but the phrase 'Prompt discarded' is ambiguous and the 9 input parameters are unrelated to generating a thinking template. It is unclear what the 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?

No guidance is provided on when to use this tool versus its many siblings. The description does not explain any scenario, prerequisite, or condition under which 'think-steps' should be invoked, and the discarded-parameter hints actively confuse rather than clarify 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 provides no behavioral details beyond the action itself. It does not disclose that only the 'zone' parameter matters, that other parameters are ignored, or that the operation is read-only and side-effect free. With no annotations, the description carries the full burden, and it fails to clarify the tool's actual behavior given the misleading schema.

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

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

The description is a single, focused sentence that directly states the tool's purpose. It is concise and front-loaded with the core action, containing 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?

For a tool with nine parameters and no output schema, the description is grossly incomplete. It fails to clarify the role of the eight non-zone parameters, does not describe the return format or any side effects, and leaves the agent guessing about which parameters are actually used. This is a severe gap for effective tool selection and invocation.

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

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

The schema already documents each parameter with descriptions, achieving 100% coverage, so the baseline is 3. The description adds no extra semantic meaning about the parameters; it only implies that 'zone' is the relevant one. It does not explain why the other parameters exist or that they 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 a clear purpose: returning the current time for a named IANA timezone. It identifies the resource (timezone) and the action (get current time), and it distinguishes from siblings like 'utc-time' and 'iana-zones'. However, the input schema contains many unrelated parameters (e.g., 'url', 'ref', 'city'), which are not mentioned and could confuse an agent 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 alternatives such as 'utc-time' or 'iana-zones'. The description gives no context about use cases, prerequisites, or exclusions, leaving the agent to infer 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?

With no annotations, the description carries the full burden of behavioral disclosure. It only states the function and does not mention that parameters are discarded, that it is a read-only operation, or any other side effects. The mismatch between the description and the generic parameters further obscures 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 concise sentence that front-loads the core purpose. However, it is under-specified and omits critical information about parameters and usage, making it insufficiently informative despite being concise.

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

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

The tool has 9 parameters, no required fields, no output schema, and no annotations. The description is a bare statement that does not explain the parameters, return value, or any usage context. It is completely inadequate for an agent to understand how to invoke this tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds no parameter meaning. The schema descriptions are generic (e.g., 'ref' for Git ref, 'city' for weather hint) and seem unrelated to the tool's stated time purpose. The description does not clarify how parameters map to the operation, leaving the 'zone' parameter ambiguous given the fixed timezone in the name.

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

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

The description clearly states a specific verb (current local time) and a specific resource (America/Lima). This is distinct from a generic timezone tool, but it does not differentiate from siblings like 'timezone' or 'utc-time' which may also provide time information. The purpose is clear but lacks sibling differentiation.

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 are no exclusions, prerequisites, or context for selecting it over sibling tools. The description only states the function without any 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description discloses only the return value (UTC timestamp) but hides that the tool apparently performs various validation checks on the 9 parameters (git ref shape, URL normalization, JSON validation, etc.) and that most inputs are 'discarded'. These behaviors are only hinted at in the schema parameter descriptions, not in the tool description, leaving an agent blind to the tool's actual operations and safety profile.

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

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

The description is a single short sentence with zero waste, but that brevity is under-specification, not conciseness. A tool with 9 parameters and a validation-like role needs more than 'Current UTC timestamp.' to be intelligible. The description is too thin to earn even a baseline 3.

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, this description is grossly incomplete. It doesn't explain what the parameters do at the tool level, how the tool relates to sibling validation tools, or what the return format is beyond 'timestamp'. An agent has no way to know if this is a pure clock or a hidden validation orchestrator.

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% — all 9 parameters have descriptions in the schema, which is the baseline 3. The tool-level description adds nothing about parameters, but the schema's per-parameter descriptions are reasonably informative (e.g., 'discarded after the shape check', 'no disk access'). The description doesn't need to duplicate what the schema covers.

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

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

The description 'Current UTC timestamp' states a clear output (the current UTC time) with an implied verb, so it's not a tautology. However, the tool accepts 9 parameters for seemingly unrelated checks (git refs, URLs, cities, JSON, paths) that the description never mentions, making the tool's overall purpose ambiguous. It also doesn't differentiate from sibling tools like 'timezone' or 'tz-america-lima', which likely return related time data.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'timezone', 'tz-america-lima', or the various shape-checking siblings (domain-shape, github-repo-shape, etc.). No when/when-not conditions, no exclusions, no context about why the 9 parameters exist. An agent cannot decide when to select this tool over a sibling.

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 states 'The body is discarded,' which conveys a no-retention trait, but does not explain what the function returns, whether it makes network calls, or what side effects (if any) occur. The many apparently unrelated parameters (url, city, host, query) suggest potentially complex behavior that 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 extremely short, with two sentences that both earn their place: the first states purpose and the second states the discard behavior. There is no irrelevant filler. It loses one point because it is so terse that it leaves out important operational details, but this is still strong 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?

The tool has 9 parameters, all optional, no output schema, and no annotations, yet the description is only two sentences. It fails to explain the return value, which parameter should be passed as 'body,' or why unrelated parameters exist. 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 description coverage is 100%, so each parameter has its own description, providing the baseline of 3. The main description adds no parameter-meaning value and does not clarify which parameter corresponds to 'body.' It neither contradicts nor enriches the schema descriptions, so the exact baseline 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 specific verb and resource: 'Check whether a body is valid JSON.' This is sufficient to distinguish it from sibling validation tools like file-path-ok or domain-shape. However, 'body' is ambiguous and not explicitly mapped to the 'json' parameter in the schema, so it is not a full 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?

The description gives no guidance on when to use this tool versus alternatives or whether a parameter is required. It does not mention any prerequisites or constraints, and the word 'discarded' does not communicate when to select the tool. The agent is left to infer everything from the schema.

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 gives no details about side effects, network calls, error handling, or rate limits. The user is left without information on what happens on failure or whether the tool makes external requests.

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 textual description is concise, but the overall tool definition is bloated by an irrelevant 9-field schema. The extra parameters and mismatched descriptions make the tool harder to understand, undermining 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?

There is no output schema, no mention of response format, units, or error behavior. Given the ambiguity in parameters and the absence of output details, the tool is not self-contained enough for an agent to use confidently.

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

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

Although the schema has 9 parameters with descriptions, the descriptions are generic and unrelated to weather (e.g., 'Git ref name', 'HTTPS URL', 'JSON text'). Only 'city' aligns with the tool's stated purpose, and the description does not clarify which parameters are actually used or required.

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: fetching current temperature for a city via Open-Meteo. However, the schema includes many unrelated fields (ref, url, feed, host, json, path, zone, query) that dilute focus and confuse the actual input requirements.

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

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

No guidance is provided on when to use this tool versus the many sibling tools (e.g., geo-hint, timezone, web-fetch). The description does not mention prerequisites, alternatives, or typical use cases.

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

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

The description mentions that the body is discarded, but it does not explain what happens with the other schema parameters, whether the request has side effects, or what the response format is. The unrelated parameter descriptions make 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, but the schema is bloated with nine optional parameters that appear to belong to other sibling tools, making the tool definition not appropriately sized for its stated purpose.

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 required parameters, no examples, and no explanation of which parameters actually matter. For a tool that appears to make network requests, important context like error behavior and return shape 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?

Although every parameter has a description, most descriptions are irrelevant to fetching a web URL: e.g., 'ref' is 'Git ref name; discarded after the shape check' and 'zone' is 'IANA timezone name'. No parameter is required, and the relationship between these fields and the stated tool purpose is unexplained.

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

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

The description states a concrete action and resource ('HTTP status and content type for a public URL'), but the schema includes nine unrelated optional parameters such as 'Git ref name' and 'City name for a public weather hint', which muddles what the tool is actually for.

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

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

The description gives no guidance on when to use this tool versus the many sibling tools like fetch-status, normalize-url, or validate-json, and no conditions or non-goals 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 only behavioral detail is 'Title discarded after the call,' which hints at data handling but does not disclose read-only nature, error behavior, or return format. With no annotations, the description carries 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 concise—two short sentences with the purpose front-loaded. Every word contributes, though the second sentence adds a minor behavioral note.

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 complex schema (9 parameters, 0 required) and lack of annotations, the description is severely incomplete. It does not explain how to pass the title, what the output looks like, or any edge cases, leaving users with no contextual guidance.

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 tool description ignores the 9 parameters entirely. The schema descriptions are generic and misleading (e.g., 'Git ref name' for a Wikipedia title check), and no explanation links them to the actual title input.

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

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

The description clearly states the tool's function: 'Check whether a Wikipedia title exists.' This is a precise verb-object statement that distinguishes it from URL-related 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 like web-fetch or normalize-url. The description lacks any context for selecting this tool.

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