Language mg

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

No annotations are provided, so the description carries the full burden. It discloses that 'Task text discarded' and 'Returns connection methods', which gives some behavioral transparency. However, it does not mention side effects, error behavior, or any safety considerations, and the description is notably brief for a tool with 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 concise, consisting of two short sentences, with the core purpose front-loaded. There is no wasted wording; it efficiently conveys the tool's function and a key behavioral note (discard).

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

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

With 9 optional parameters, no required fields, and no output schema, the description is insufficient. It does not explain what 'connection methods' actually look like, how to choose which parameters to provide for a given task, or how the discard behavior applies. An agent lacks critical information to call this tool correctly and interpret its 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?

The input schema has 100% coverage with per-parameter descriptions, so the baseline is 3. The description adds minimal parameter context—it mentions example task types but does not map them to specific parameters (e.g., city for weather). It does not enhance understanding 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 clearly states the tool's action ('Find a public pay-per-call tool gateway') and resource (gateway for tasks), with examples (weather, search, scrape, voice). It also mentions the output ('Returns connection methods'). It is distinct from sibling tools which are specific checks, but it doesn't explicitly differentiate itself beyond the general 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 implies usage scenarios ('for a task such as weather, search, scrape, or voice'), giving some context. However, it does not explicitly state when to use this tool versus the many sibling tools, nor does it provide any exclusions or alternative tool recommendations.

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

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

With no annotations present, the description carries the burden of behavioral disclosure. It does disclose one useful trait, that no browser is launched, but it says nothing about whether network or filesystem access occurs, whether state is modified, or what a successful or failed check looks like.

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, and the core purpose is front-loaded. It earns its length, even if it could carry more substance.

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

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

The tool has nine optional parameters, no output schema, and no annotations, so a single high-level sentence is not enough. The description does not explain how to select parameters or what the caller would receive after the check.

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 little beyond the schema and does not clarify which of the nine optional fields is the primary target for the check, but the schema itself documents each parameter.

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

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

The description clearly states a verb and resource: 'Check whether a URL can be opened' and adds the useful differentiator 'No browser is launched.' It is not a tautology, but 'opened' is left somewhat vague and it does not explicitly distinguish itself from related siblings like playwright-url-ok, fetch-status, or normalize-url.

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

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

There is no guidance about when to use this tool versus alternatives, no conditions, and no exclusions or recommended scenarios. An agent cannot tell whether to choose this, playwright-url-ok, or web-fetch from the description alone.

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

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

With no annotations provided, the description must disclose behavior, but it only says 'Expression discarded' which is meaningless since no expression parameter exists. It doesn't explain side effects, permissions, or what the tool actually does with its input parameters. This is severely 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 short (two sentences), but brevity is not conciseness here. It lacks any useful information and fails to front-load key details. It reads like a placeholder rather than a purposeful, compact explanation.

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 with rich schema descriptions and no output schema, the description should explain which parameters are relevant, how they relate, and what the tool returns or checks. It provides none of this, making it completely inadequate for an agent to use correctly.

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

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

The description adds no meaningful semantics for any of the 9 parameters. It mentions arithmetic but doesn't connect to parameters like URL, city, or query. Even though schema coverage is 100%, the description's mention of arithmetic actively confuses rather than clarifies how parameters are used.

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

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

The description states 'Evaluate a+b style arithmetic' which implies a calculation tool, but none of the 9 input parameters (ref, url, city, feed, host, json, path, zone, query) relate to arithmetic. The purpose is unclear and disconnected from the actual parameters, and it doesn't differentiate from any of the 30 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?

There is no guidance on when to use this tool versus alternatives. The description gives no context about typical use cases, prerequisites, or scenarios where this tool is preferred over its siblings.

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

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

The description does disclose an important privacy-related behavior: page content is not stored. However, with no annotations provided, the description carries a heavier burden; it is still silent on network-fetch behavior, redirects, attempt semantics, and what happens with the many discarded input fields.

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 result is front-loaded and the privacy statement adds meaningful behavioral information without adding clutter.

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

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

For a simple URL-status operation, the description covers the basic purpose enough; however, this schema includes 9 named parameters, zero required fields, and no output schema. The description does not clarify the intended parameter combination for the described 'URL' behavior, making the call contract ambiguous for an agent.

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

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

Schema description coverage is 100%, so the parameters are already documented in the input schema and the description does not need to repeat them. Still, the description adds no parameter-specific guidance about which of the nine fields is the intended source of the URL behavior, so it only meets the high-coverage baseline.

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 output: returning host, scheme, and HTTP status for a URL. It adds a relevant boundary by saying page content is not stored, but it does not explicitly distinguish itself from sibling tools like normalize-url or fetch-status, and the title 'citation' is ambiguous without more context.

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

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

There is no guidance about when to prefer this tool over sibling alternatives such as normalize-url, fetch-status, or web-fetch. The phrase 'for a URL' implies a use case, but the description provides no when-to-use, when-not-to-use, or alternative routing information.

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

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

With no annotations, the description must carry the transparency burden. 'No identifiers are retained' is a meaningful privacy disclosure, and some parameter descriptions note 'discarded' or 'no disk access', but the tool's side effects, computational behavior, and result format remain 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 short and the second sentence adds a meaningful privacy note, but the first sentence is ambiguous and wastes the leading position on a vague phrase rather than a specific 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?

For a tool with 9 diverse optional parameters, no annotations, and many sibling validators, this description is far too sparse. It doesn't state what 'compatibility' means, how inputs are mapped, what the classification output looks like, or when an agent should reach for 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?

Schema description coverage is 100%, so every parameter is already documented. The description adds no additional parameter-level insight beyond the schema, so the baseline 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 uses a verb ('Show') and a resource ('this request'), but 'how this request is classified' is vague. It does not explain what classifications exist, what output to expect, or how it differs from the many sibling validator 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?

There is no guidance about when to use this tool versus its alternatives. Null sibling references, no exclusions, and no context about which of the other 28 tools it relates to or supersedes.

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 claims to split hostnames but the parameters include many unrelated fields, and the description gives no hint of side effects (e.g., 'discarded after the check' implies no persistence, but the general behavior is unclear). It doesn't mention whether any inputs are actually used for the stated task or if the tool is a multiplexer that behaves differently per parameter. The description is too vague to set expectations.

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

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

The description is a single short sentence, which is concise, but it omits necessary information and is misleadingly brief for a tool with 9 parameters. It front-loads 'Split a hostname' but doesn't acknowledge the other use cases, so the brevity works against clarity. It earns a 3 for being short, but the structure fails to organize the tool's actual scope.

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

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

Given the tool has 9 optional parameters, no output schema, and no annotations, the description is severely incomplete. It only mentions hostname splitting while the schema implies a multi-purpose validation tool. Without an output schema, the description should explain what the tool returns (e.g., a shape check result), but it says nothing. An agent cannot know what to pass or what to expect for most of the parameters. This is inadequate for a tool of this complexity.

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

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

Schema description coverage is 100%, meaning each parameter has a description in the schema. However, the overall tool description does not add meaning beyond the schema; it actually contradicts the schema by implying the tool only handles hostnames while the schema shows it handles 9 distinct field types. The schema descriptions are self-contained, but the tool-level description fails to explain how parameters relate to the stated purpose, so the agent gets conflicting signals about what to pass.

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 ('Split') and a resource ('hostname'), but the purpose is misleading because the input schema accepts 9 unrelated parameters (URL, city, feed, JSON, path, zone, query) that have nothing to do with splitting hostnames. The tool name 'domain-shape' and the description suggest a narrow function, but the schema reveals it accepts arbitrary inputs for various checks, so the description under-specifies the actual behavior and doesn't distinguish it from siblings like 'normalize-url' or 'geo-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?

No guidance on when to use this tool versus alternatives. With 29 sibling tools covering many of these inputs (e.g., 'normalize-url', 'geo-hint', 'validate-json', 'search-query-len'), the description provides no exclusions or selection criteria. The tool is a catch-all, but the description fails to explain when to use it instead of a more specific 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 does disclose that it performs a HEAD request and returns only status, implying a read-only, non-destructive operation. However, it fails to explain what happens when non-URL parameters are provided; the schema descriptions hint at other actions (e.g., 'discarded after the shape check') that are not mentioned, leaving the tool's behavior opaque.

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

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

The description is a single, front-loaded sentence, so it is structurally concise. However, it is under-specified rather than efficiently rich; it omits crucial information about the other parameters and usage context, so the brevity does not earn 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 9 optional parameters and no output schema, the description is severely incomplete. It only covers the URL path and ignores the entire multi-parameter behavior implied by the schema. There is no mention of what the returned status looks like, when the other parameters are used, or any requirements beyond 'public 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 each of the 9 parameters has its own meaning in the schema. The tool description adds no parameter-specific detail, so it does not enhance the schema. The baseline for full coverage is 3, and while the parameter descriptions themselves are somewhat inconsistent with the tool's stated purpose, they still provide meaning beyond bare names.

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

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

The description clearly states the core action: 'HEAD a public URL and return status only.' That is a specific verb and resource. However, the schema lists 8 additional parameters (ref, city, feed, json, zone, etc.) whose descriptions imply other behaviors (shape checks, weather hints, validation), and the description gives no hint about them. This creates ambiguity about what the tool actually does beyond the URL case.

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

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

No guidance is given on when to use this tool versus siblings like browser-url-ok or playwright-url-ok, which likely also check URL availability. The description does not mention any criteria that would route an agent to this tool instead of 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?

No annotations are provided, so the description must carry the behavioral burden. It only says 'parse' and 'path discarded,' leaving the agent to guess network behavior, return values, failure modes, and side effects. This is too thin for a tool with no other behavioral metadata.

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

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

The description is very short and front-loads the essential purpose. It has no filler, though 'Path discarded.' is so terse that it creates 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?

With 9 parameters, no required parameters, no output schema, and no annotations, the description leaves too much unspecified: which parameter to pass, what the tool returns, what 'path discarded' refers to, and what error or failure modes exist.

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

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

Schema coverage is already 100%, so the baseline is 3. The description adds little beyond clarifying that the relevant URL is a Figma file URL; it does not map the 9 parameters to actual usage or distinguish which ones are relevant to parsing a Figma 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 clearly names a specific action and resource: parse a Figma file URL. The tool name and the sentence together make it distinguishable from sibling shape-check tools, even though 'Path discarded.' is a bit terse.

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 normalize-url, domain-shape, github-repo-shape, or playwright-url-ok. The description implies it is for Figma URLs but does not state prerequisites, expected usage, or why this shape-check is preferred in a given 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, and it only discloses 'No disk access' – a useful safety trait. It fails to explain what 'safe' means, what the tool returns, or how it treats the eight other schema parameters, several of which are described as 'discarded' in the schema but not in the 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 brief and front-loaded, with no wasted words. However, it is under-specified for a tool with nine optional parameters, so the brevity comes at the cost of necessary context.

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

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

The description is incomplete for a tool with nine optional parameters, no annotations, and no output schema. It doesn't define the safety criteria, the return value, or how the non-path parameters relate to the tool's purpose, and it doesn't help the agent choose among the many sibling 'ok' 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?

Schema description coverage is 100%, so the schema already documents all nine parameters. The description adds no parameter-level meaning beyond the schema; 'No disk access' simply repeats the path parameter's schema 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 states a specific action ('Check whether a path looks safe') and a key constraint ('No disk access'), making the core purpose clear. However, 'looks safe' is vague about what safety means, and it doesn't explicitly differentiate from sibling URL/shape checkers like browser-url-ok or wiki-title-ok.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention any sibling tools, conditions, or exclusions, leaving the agent to infer that it's for path validation only.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose one external dependency ('via Open-Meteo'), but it neglects to state the return format, whether a network request is required, rate limits, error behavior, or that supplied params are discarded and not persisted.

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. It is appropriately brief for an operation that appears to be a simple lookup, but the extreme under-specification borders on missing content rather than genuine 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?

For a tool with 9 optional parameters, zero annotations, and no output schema, the description is far too sparse. It does not explain how the returned latitude and longitude are formatted, which parameter must be used, what happens when other parameters are supplied, or how this fits alongside 28 sibling tools. Several schema descriptions (ref, url, json) come from other feature contexts and are never reconciled with the stated geocoding 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?

Schema description coverage is 100%, so the baseline of 3 applies. The description adds almost no parameter-level meaning: it does not indicate that only the city parameter is relevant, nor that the other eight params are unrelated to geocoding. The schema's per-parameter descriptions are self-contained, while the tool description contributes only the upstream API association.

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 output: latitude and longitude for a place, with the upstream source stated (Open-Meteo). However, it lacks an explicit verb ('get', 'resolve') and does nothing to differentiate it from geospatially adjacent siblings such as weather-hint or timezone.

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

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

No guidance is given on when to use this tool instead of alternatives, nor which of the 9 optional parameters constitutes 'a place' (only 'city' plausibly maps, but the schema describes it as 'a public weather hint', which is inconsistent with geocoding). An agent cannot determine which parameters are relevant or whether the other eight should be ignored.

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

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

No annotations are provided, so the description carries the full burden. It only says 'parse', which doesn't disclose that other parameters are discarded after shape checks, that this is a validation-style tool, or what happens on invalid input. The schema hints at behavior ('discarded after the shape check') but the description itself is opaque.

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

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

The description is a single sentence and is concise, but under-specification hurts. It is front-loaded with the main action, yet it omits necessary scope information about the other parameters and potential behaviors. Concise but not sufficiently structured to cover the tool's breadth.

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, all optional, and no output schema, a one-sentence description is inadequate. The agent cannot know what the tool returns, how it handles the various inputs, or when it should be selected over siblings. The description is incomplete even for basic invocation.

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

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

Schema description coverage is 100%, so each parameter already has a description. The tool description adds a little context by implying the 'url' parameter is for parsing owner/repo, but it doesn't clarify the purpose of the other 8 parameters. Baseline 3 is appropriate since the schema does most of the work.

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

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

States a specific verb and resource: parse owner and repo from a GitHub URL. It distinguishes from sibling shape tools (e.g., domain-shape, figma-url-shape). However, the presence of 9 unrelated parameters in the schema makes the actual purpose ambiguous – the description covers only the URL case and fails to clarify how the other parameters fit.

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 implies it is for GitHub repo URLs but doesn't contrast with normalize-url or domain-shape. There is no explicit when/when-not, leaving the agent to infer if this is the right tool for 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?

No annotations are provided, so the description carries the full burden — and it actively misleads. It claims a live count of current HN front-page stories, implying real network access, while the schema signals the opposite: parameters like 'feed' (titles discarded) and 'path' (no disk access) reveal this is a pure shape check with no fetching. The description discloses none of this and sets false expectations about observable 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?

Two short sentences, front-loaded with the intended action. 'Titles discarded' echoes the schema's discard semantics efficiently. The brevity itself is not a flaw, though it is so short that it omits the essential behavioral context.

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

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

With 9 optional parameters, zero annotations, no output schema, and no explanation of how the count is produced or returned, the description is grossly incomplete. An agent cannot tell which parameter to pass for a count, whether the result is a number, or what happens when inputs are discarded — everything an agent needs 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?

Schema description coverage is 100%, so the baseline is 3 even though the description adds nothing about parameters. The schema descriptions are individually clear about each field, but they do not connect any parameter to producing an HN count — a semantic gap the description fails to bridge, since it names no parameter that yields the story count.

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

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

The description names a specific action ('Count current Hacker News front-page stories') but this purpose is contradicted by the schema, where every parameter is described as 'discarded after the shape check', 'discarded after the call', or otherwise discarded. The tool is structured as a shape-validation stub (mirroring sibling tools like domain-shape, github-repo-shape), yet the description promises a real network fetch and count that the parameter list gives no mechanism to perform.

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

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

The description offers zero guidance on when to invoke this tool versus any of its 28 siblings, none of which would plausibly produce an HN story count. No context, no exclusions, no alternatives are given — an agent is left with no basis to select it correctly.

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 is a noun phrase and reveals no output, side effects, call expectations, or the fact that many input parameters appear to be discarded after checks.

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

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

The description is short and front-loaded, but it is under-specified rather than efficiently concise. For a tool with 9 parameters and no output schema, one sentence with no behavior or parameter context is too thin.

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 annotations, and no output schema, but the description explains neither the operation nor how the parameters connect to the purpose. An agent would be unable to know what to return or which values to populate.

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 every parameter already has a meaning in the input schema. The tool description adds no additional parameter semantics and does not explain which of the nine parameters actually matter or why the others are 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 names a resource ('Common IANA timezone names') and an intended use ('for clock calls'), so a reader can weakly infer that the tool returns or catalogs timezone names. It lacks a verb or explicit operation, and it does not distinguish this from sibling tools like timezone or utc-time.

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

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

The only guidance is 'for clock calls,' which gives a vague context but no concrete when-to-use/when-not-to-use guidance. It never mentions alternatives or how this differs from closely related sibling tools such as timezone and utc-time.

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 side effects, authentication needs, or error behavior, but it only mentions that it returns group counts. It fails to mention that many parameters are discarded after a shape check (as seen in the schema) or that the tool may perform different operations depending on the parameter supplied, leaving agents unprepared for unexpected 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 sentence, which is concise in length, but it is not well-structured for the tool's complexity. It front-loads one narrow use case while hiding the tool's multi-parameter nature, and it omits any disambiguation or usage context. Conciseness without accuracy or completeness is not effective.

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

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

Given 9 parameters, no annotations, and no output schema, the description is severely inadequate. It does not explain the tool's multi-functionality, how parameters are selected, what responses look like, or when to use it. An agent would be unable to correctly call this tool beyond a naive robots.txt fetch and could easily misuse it for unrelated parameters.

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

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

The schema descriptions cover 100% of the parameters, so the baseline is 3. The description adds no parameter information beyond what the schema already provides; for example, it does not clarify which parameter (if any) is used for the robots.txt URL. Since the schema is complete and parameters are self-describing, this is acceptable but not enhanced by 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 states a specific action ('Fetch a public robots.txt and return group counts only'), but the schema lists 9 parameters, many of which (city, feed, json, query, etc.) have no connection to robots.txt. This implies the tool actually performs multiple unrelated checks, making the stated purpose incomplete and misleading. An agent cannot accurately infer the tool's full scope from this description.

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

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

There is no guidance on when to use this tool versus its 28 siblings or when not to use it. The description does not mention that the tool can handle multiple inspection tasks based on which parameter is provided, nor does it clarify when to pick 'inspect-robots' over 'web-fetch' or 'fetch-status'.

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 key is 'discarded,' implying no persistence or side effects, which is useful. But with no annotations provided, the description carries the full burden and fails to state what the check returns, whether it makes a network call, or how invalid shapes are handled. This is insufficient behavioral disclosure.

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

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

The description is extremely concise: two short sentences with no filler. It is front-loaded with the primary purpose. However, the brevity omits critical mapping details, so while structurally efficient, it sacrifices necessary 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?

For a 9-parameter tool with no annotations and no output schema, this description is severely incomplete. It fails to identify which parameter is the Jira key, does not describe the result format, and gives no error or edge-case behavior. An agent has almost no basis to invoke it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3, but the parameter descriptions are generic ('Git ref name', 'HTTPS URL', 'City name', etc.) and none of them clearly references a Jira issue key. The tool description mentions a key but gives no indication which parameter should receive it, making the parameter semantics misleading rather than clarifying.

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 action and resource: 'Check a Jira issue key shape.' This is clear at a high level and distinguishes the tool from sibling shape-checkers by name. However, it does not map the Jira key to any of the 9 input schema parameters, leaving the agent uncertain which field to populate.

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 github-repo-shape, figma-url-shape, or domain-shape. The description only says what it does, not when an agent should select it over siblings or what conditions make it appropriate.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It provides zero information about what happens when the tool is called, what side effects occur, or what the response looks like. For a tool with 9 parameters, this is a critical omission.

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, which is concise, but it is under-specified. It contains no actionable information and does not earn its place by adding value. It is more of a placeholder than a helpful 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 9 parameters, no output schema, and no annotations, the description is grossly incomplete. It fails to explain the tool's purpose, behavior, or output, leaving an agent unable to determine how to call it correctly or interpret results.

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

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

Schema description coverage is 100%, so each parameter has a brief description. However, the tool description adds nothing to explain how these parameters relate to the tool's purpose, making their usage ambiguous. The parameter descriptions are generic and disconnected from any clear function.

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

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

The description 'ISO 639 language tag mg.' merely expands the tool name and does not state what the tool does. It lacks a verb and resource, and does not distinguish it from siblings like timezone or validate-json. This is effectively a tautology.

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 or how it differs from alternatives. The description gives no context, conditions, or exclusions, 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'body discarded,' but says nothing about what the tool actually does with the other parameters, whether it makes network requests, what it returns, or any side effects. This is severely opaque for a tool with nine inputs.

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, but it is under-specified rather than concise. It omits critical information about what the tool does with the majority of its parameters. Conciseness should serve completeness; here it sacrifices it.

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

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

With nine parameters, no output schema, and no annotations, the description needs to explain the tool's purpose, behavior, and input usage. It fails on all accounts. An agent cannot correctly call this tool 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%, and each parameter has a short description (e.g., 'discarded after the shape check'). The tool description adds no extra meaning beyond what the schema already conveys, which is the baseline expectation. No additional value is provided.

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 ('HTTP status') and resource ('public library docs URL'), but the input schema exposes nine unrelated parameters (city, feed, zone, query, etc.) that are not mentioned at all. This makes the actual purpose ambiguous – it appears to be a generic 'hint' tool, not solely a URL status checker. 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?

There is no guidance on when to use this tool versus the many sibling tools. No mention of which input types it accepts, what scenarios it fits, or which alternatives might be better. An agent has no basis to choose it.

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

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

No annotations are provided, so the description carries the full burden. It discloses only 'Values discarded', which hints at a read-only, non-persistent operation but says nothing about return format, error behavior, or side effects. For a tool with 9 parameters and no annotation support, this is a significant gap in behavioral disclosure.

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

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

The description is a single, concise sentence that front-loads the core purpose ('Count keys in a JSON object'). It wastes no words, but the brevity comes at the cost of essential context. It is appropriately sized for a minimal statement, but the under-specification limits structural completeness.

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

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

Given the tool's complexity—9 optional parameters, no output schema, and no annotations—the description is woefully incomplete. It fails to explain what the tool actually does with the various inputs, whether it expects a JSON string, how the count is returned, or when to invoke it. An agent would have to infer most behavior from the schema, with no guidance on the overall operation.

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

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

Schema description coverage is 100%, so all 9 parameters are individually described (e.g., 'json' is 'JSON text to validate; discarded after the check'). The description itself adds no parameter meaning—it does not explain how parameters relate to key counting. Since the schema already handles parameter documentation, the baseline of 3 is appropriate, but the description's silence about parameter roles prevents a higher score.

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 ('Count') and resource ('keys in a JSON object'), but it is ambiguous how this relates to the 9 input parameters, each of which is a separate string. It does not clarify which parameter(s) represent the JSON object to be counted, nor does it differentiate from overlapping siblings like validate-json or domain-shape. The line 'Values discarded' adds a detail, but the overall purpose is under-specified.

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 any of the 27 siblings. It does not mention alternatives, exclusions, or contexts such as 'use when you need a key count from a JSON string'. The description provides no actionable usage direction.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. It does state the main output (origin, host, path) and that query/fragment are dropped, which is useful. However, it fails to mention that the many auxiliary parameters (ref, city, feed, json, zone, query, etc.) are ignored or discarded, nor does it address error handling or invalid URL behavior. This is a significant gap.

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

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

The description is a single, compact sentence that front-loads the primary outcome. It is efficient with no filler. However, it could be slightly more structured by naming the 'url' parameter explicitly, but overall it is concise and readable.

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

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

Given the tool has 9 parameters, no output schema, and a mix of irrelevant parameters in the schema, this description is inadequate. It does not clarify which parameter is the primary input, how the return value is formatted (string, object, etc.), or what happens with invalid URLs. The presence of many discarded parameters is not addressed, leaving the agent with significant ambiguity about 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 description coverage is 100% for all 9 parameters, so the schema already provides detailed descriptions for each. The tool description adds no parameter-level information beyond the schema. It does implicitly reference the 'url' parameter via 'for a URL', but does not elaborate on its format or constraints, leaving the schema to carry the semantic load as expected.

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 ('Return') and resource ('origin, host, and path for a URL') and specifies that query and fragment are dropped, which distinguishes it from sibling URL tools like browser-url-ok or fetch-status. However, it does not explicitly name the 'url' parameter as the sole input, leaving ambiguity given the 9 unrelated parameters in the schema.

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

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

No guidance is provided on when to use this tool instead of alternatives, nor any exclusion conditions. The description mentions only the operation, not the decision context. An agent gets no hints about prerequisites or when this tool is preferred over other URL-related siblings.

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

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

The description says 'No browser is launched' and implies URL checking, but the parameters suggest the tool validates a wide range of data shapes (e.g., JSON, timezone, search text) and discards inputs afterward. This is a major contradiction between the stated behavior and the actual operation. With no annotations, the description carries full burden, and it fails to disclose what the tool truly does, any side effects, or return values.

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 and is concise with no filler. However, it is under-specified for a tool with nine parameters, so while it is concise, it sacrifices necessary detail. The structure is acceptable but not front-loaded with the most critical 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, no output schema, no annotations, and a description that only mentions URL checking, the tool is severely incomplete. An agent would not know what the tool returns, how to interpret the parameters, when to invoke it, or what errors may occur. The description fails to provide the context needed 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?

The schema covers all 100% of parameters with individual descriptions, so the baseline is 3, but the tool description adds no value to parameter understanding. The mismatch between the declared URL-checking purpose and the diverse parameters (e.g., city, path, zone) makes it unclear how to use them 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 'Check whether a URL can be opened', which is a clear verb-resource pair, but the input schema accepts nine diverse parameters including city, json, path, zone, and query that have no relation to URLs. This makes the stated purpose misleading and fails to convey the tool's actual function as a multi-type shape validator.

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 or fetch-status. There are no conditions, exclusions, or mention of alternatives, 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?

With no annotations, the description carries the behavioral disclosure burden. It only says 'Query discarded', which is already present in the query parameter's schema description. It does not state what the tool returns, whether it has side effects, or that only the 'query' parameter is relevant among the 9 optional inputs.

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, containing exactly two purposive sentences. There is no fluff or repetition, which earns full marks for conciseness.

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

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

The tool accepts a large schema with 9 optional parameters and no output schema. The description does not explain why so many parameters are present, which of them are actually used, or what the output format is when characters are counted. This ambiguity makes the description insufficient for the complexity level of the input schema.

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

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

Schema description coverage is 100%, and the description adds little beyond what the schema already says for 'query'. It does not clarify the relationship among the large set of optional parameters, so it stays at the baseline.

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 'Count' and the resource 'characters in a search query', giving the primary intent. However, it does not differentiate from sibling length-related tools like hn-front-count or memory-key-count, so it only reaches a 4.

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 not to. It does not mention alternatives or any context like 'use this only when you need to check query length', so the agent receives no usage direction.

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

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

No annotations exist, so the description carries the full burden for behavioral disclosure. It merely says the tool is a 'short catalog', implying read-only static output, but it never discloses how parameters are handled, whether output varies by input, or whether the params are discarded. The schema reveals these are discarded, but the description itself does not communicate that.

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

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

The description is a single short sentence with no fluff, which makes it structurally efficient. But it is under-specified for a tool with nine parameters and no annotations; the brevity is closer to a title than a helpful description. It earns a middle score for compactness without sacrificing clarity, but misses needed 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?

This tool has nine parameters, no output schema, and no annotations, so the description must do heavy lifting that it does not. It never explains what an agent should pass in, what the tool will return, how the parameters are used, or how this differs from sibling status-checking tools. The description is drastically incomplete for correct invocation.

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

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

Schema description coverage is 100%, so the baseline is 3; the schema already explains each parameter. The description adds no additional meaning about how these unrelated parameters (city, feed, json, zone, etc.) relate to the catalog, but it also doesn't need to if the schema is sufficient. However, the disconnect between the catalog title and the parameters leaves semantic ambiguity.

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

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

The description names a specific resource ('common HTTP status codes') and calls it a 'catalog', so an agent can infer it returns a reference list. However, there is no verb like 'lists' or 'returns', no scope detail, and no differentiation from siblings such as fetch-status or browser-url-ok, so the purpose is only partially clear.

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

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

There is no guidance about when to use this tool, when not to, or how it relates to sibling tools like fetch-status or browser-url-ok. Nothing is misleading, but the description provides no context to help an agent choose this tool over alternatives.

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

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

With no annotations, the description must disclose behavioral traits. It states 'Prompt discarded,' which suggests the tool ignores input, but this is contradicted by the parameter descriptions that imply each parameter has a specific purpose (e.g., 'normalize or cite', 'validate', 'check'). The description doesn't clarify whether parameters are actually used or ignored, nor does it mention any side effects, return format, or whether the template is fixed. This lack of clarity is a transparency gap.

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

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

The description is extremely concise—one short sentence. That is efficient in length, but it is underspecified. It front-loads the main action ('Return a three-step thinking template') but omits any elaboration on the template or the role of parameters. Concise yes, but it lacks necessary structure to be effective; it reads more like a stub than a complete 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?

Given the tool has 9 parameters, no output schema, and no annotations, the description is very incomplete. It doesn't explain what the three-step template is, how the parameters relate to it (if at all), or what the agent should expect as a response. The 'Prompt discarded' hint is ambiguous and doesn't help the agent understand the tool's behavior. For a tool with this many parameters, much more context is needed.

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% because each parameter has a description. The tool description itself adds no parameter-level information beyond what the schema provides. The parameter descriptions in the schema are detailed individually, so the baseline of 3 is appropriate. However, the tool description doesn't reconcile those parameter descriptions with the 'Prompt discarded' statement, so it doesn't add semantic 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 a specific verb and resource: 'Return a three-step thinking template.' This is clear as a purpose. However, it doesn't differentiate from sibling tools, and the phrase 'Prompt discarded' is confusing—it doesn't clarify whether the parameters are used at all or if the tool simply ignores all input. The purpose is clear but lacks specificity and context.

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

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

The description provides no guidance on when to use this tool versus other tools. It doesn't mention any prerequisites, exclusions, or alternative tools. The 'Prompt discarded' line implies the tool doesn't use the prompt, but it doesn't explain when an agent should invoke this tool instead of something else. Usage context is entirely absent.

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

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

Annotations are absent, so the description carries the full burden. It implies a read-only operation by saying 'current time describes the primary behavior but does not disclose DST handling, invalid zone responses, or any resource limits. For an apparent leaf utility this is minimally acceptable.

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

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

The description is a single seven-word sentence that front-loads the action, makes no redundant claims, and is easy to parse. There is no wasted text.

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 receives 9 parameters with 8 irrelevant decoys, no annotations, and no output schema. The description does not distinguish the meaningful parameter or describe the expected response, so it is not complete enough for an agent calling correctly in this context.

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

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

Schema description coverage is 100%, so the baseline is 3. The description aligns with the 'zone' parameter, but it does not explicitly tell the agent to use only 'zone' and ignore the other eight parameters that are apparently decoys.

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: it returns the current time for a named IANA timezone. It does not explicitly compare against related siblings like iana-zones or utc-time, but the core purpose is unambiguous.

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

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

There is no guidance on when to use this tool versus alternatives such as utc-time or iana-zones, nor any when-not-to-use conditions. The agent must infer usage purely from the tool name and the laconic description.

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

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

With no annotations, the description carries the full burden, and 'Current UTC timestamp' at least reveals that the tool performs a read-only time lookup. However, it does not disclose the timestamp format, nor does it explain that all nine input parameters are effectively ignored, although the schema parameter descriptions partially cover that.

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 that communicates the tool's main behavior with no filler. It is a model of conciseness, even though other dimensions penalize missing 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?

For a trivial time-lookup tool, the description captures the essential outcome, and the schema covers the optional ignored parameters. The main missing context is the exact return representation and any connection to time-zone siblings, but the tool is simple enough that this is not a severe gap.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description itself adds no parameter meaning. It does not mention that all parameters are optional and discarded, but the schema already states this behavior per-parameter.

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

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

The description 'Current UTC timestamp' states the tool returns the current UTC time, which is clear and actionable. It does not explicitly differentiate it from siblings such as 'timezone' or 'iana-zones', so it misses the top level of clarity.

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

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

There is no guidance about when to use this tool instead of alternative time-related tools like 'timezone' or 'iana-zones'. The simple phrase implies a use case, but it leaves all selection decisions to inference.

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

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

With no annotations, the description carries the full burden. It only states that the body is discarded, but does not disclose return values, error behavior, or whether any state changes occur. The agent is left wondering what the tool actually returns (e.g., boolean, success/failure) and what side effects exist.

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

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

The description is extremely concise: two short sentences with no filler. The core action is front-loaded, and the extra note about discarding the body is useful and non-redundant. Every word earns its place.

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

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

The tool has 9 optional parameters and no output schema, yet the description gives no guidance on how the parameters should be used for validation. The presence of unrelated parameters like 'city', 'zone', and 'ref' is unexplained. The description is insufficient for an agent to confidently construct a correct invocation.

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

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

The input schema provides 100% coverage with each parameter described. The tool description adds no additional meaning to the parameters, but since the schema already documents them, a baseline score of 3 is appropriate. The description does not need to repeat schema info.

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

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

The description clearly states a specific action: 'Check whether a body is valid JSON.' This distinguishes it from sibling validation tools like file-path-ok or browser-url-ok, which target different input types. The action is unambiguous and focused.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention any conditions, prerequisites, or scenarios where this tool is preferred over other validators. There is no 'use when' or 'use instead' 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Current temperature for a city via Open-Meteo' and reveals nothing about side effects (e.g., network access, data discarding, read-only nature). The schema hints that many inputs are 'discarded' but the description does not surface this, leaving an agent blind to what actually happens beyond the temperature call.

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

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

The description is extremely concise, a single sentence with no filler. It is front-loaded with the core purpose. However, the brevity sacrifices necessary detail about the tool's broader capabilities, making it concise but ultimately insufficient for its complexity.

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

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

This tool has 9 parameters, no required fields, no output schema, and no annotations—all complexity must be addressed in the description. The description completely fails to explain the multi-purpose nature, the relationship between parameters, return values, or when to use each input. An agent cannot correctly invoke this tool for anything other than a simple weather query, and even then it is unclear what the response will contain.

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% and each parameter has its own description, so the schema already covers semantics. However, the tool description fails to clarify why there are 9 parameters when it promises only weather. It does not explain that only 'city' is relevant for the weather feature and that other parameters serve different purposes. The description adds no value over the schema and even misleads about the parameter space.

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 function ('Current temperature for a city via Open-Meteo') but is misleading because the input schema includes 9 parameters covering a wide range of unrelated tasks (e.g., JSON validation, file path checks, search query length). An agent would not understand the tool's actual scope from this description alone; it appears to be a multi-purpose 'hint' tool, and the description highlights only one feature.

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 the many siblings (e.g., 'geo-hint', 'validate-json', 'search-query-len'). It does not mention that it can handle other input types or that weather is just one use case. An agent has no way to route between this tool and alternatives.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It does disclose that the body is discarded and that the URL must be public, which is useful. However, it omits key behaviors such as redirect handling, timeouts, rate limits, error responses, and the exact format of the returned status/content type. This is insufficient for a tool that will be invoked autonomously.

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

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

The description is two sentences with zero redundancy. It front-loads the core purpose ('HTTP status and content type') and then adds the necessary qualifier about the body being discarded. This is exemplary conciseness with an efficient structure.

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

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

The tool has 9 optional parameters, no output schema, and no annotations. The description is far too sparse to guide an agent on how to construct a valid invocation, which parameter to use, or what the response will look like. The mismatch between the generic description and the broad parameter set makes the tool appear ambiguous and 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 coverage is 100%, so the baseline is 3. The description adds no parameter-specific guidance; it does not clarify which of the 9 parameters is the primary 'url' input, and the schema descriptions for parameters like 'city' and 'zone' seem unrelated to the stated purpose. The description fails to meaningfully enhance parameter understanding beyond what the schema already provides.

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: retrieving HTTP status and content type for a public URL, with body discarded. This is a specific verb-resource pair (fetch/check a URL) and not a tautology. However, it does not explicitly distinguish itself from similar siblings like 'fetch-status' or 'browser-url-ok', which may also perform HTTP checks, so it 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 usage guidance is provided. The description does not indicate when to use this tool over alternatives, nor does it mention any prerequisites, exclusions, or context in which it should be favored. An agent cannot infer the appropriate selection criteria.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states 'Title discarded after the call,' which is a retention hint, but it does not explain the actual behavior: how the existence check happens, what is returned, whether network access is involved, error handling, or side effects. This is severely inadequate for a tool with no annotation coverage.

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

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

The description is short (one sentence), which is concise, but the conciseness is a product of under-specification. It front-loads the purpose but omits all crucial operational details. The structure is not helpful because it leaves the agent unable to map parameters to the intended action.

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 parameters, no annotations, no output schema), the description is woefully incomplete. It does not explain which parameter carries the title, what the tool returns, any prerequisites, or how it integrates with the sibling tools. The description fails to provide an agent with the information needed to call the tool correctly.

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

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

The description adds no meaning beyond the schema. It does not indicate which of the nine parameters corresponds to a Wikipedia title, nor how the parameters relate to the title check. The schema descriptions are generic and mismatched (e.g., 'url' for normalize or cite, 'query' for search text), and the description fails to reconcile these with the tool's stated purpose. With 100% schema coverage but zero semantic integration, the parameter semantics are nearly useless.

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'), but the input schema contains no parameter named 'title' or any obvious mapping to one. The nine parameters (ref, url, city, feed, host, json, path, zone, query) are unrelated to Wikipedia titles, so the purpose is confused and misleading about how the tool is actually invoked.

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

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

There is no guidance on when to use this tool versus siblings like browser-url-ok, domain-shape, or normalize-url. The description does not mention any context, alternatives, or exclusions, leaving the agent without criteria for selecting this tool over others.

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