ISO country SY

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

Beyond the readOnly/idempotent/destructive-safe annotations, the description adds a useful behavioral detail: 'Task text discarded.' It also clarifies that this is a lookup/index operation by stating what is returned, which helps an agent predict the side effects and output shape.

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?

One compact sentence covers purpose, target, return contents, and a behavioral caveat with no filler. Every clause earns its place, and the most distinctive information is front-loaded.

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 tells an agent what the tool finds and returns, and the schema covers all seven inputs. With no output schema, the explicit return-item list and the 'task text discarded' caveat provide sufficient context for safe invocation, though it could say a bit more about what Monid is and when it is the relevant target.

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 all parameters are already documented. The description adds only the global caveat that task text is discarded, which is useful but does not provide per-parameter meaning beyond what the schema already states.

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 and resource: 'Find a public pay-per-call tool gateway (Monid)' and lists the concrete returned artifacts (CLI setup, how-it-works, skill file, remote MCP hops). It distinguishes the tool from the general web-fetch and validation siblings, though it does not explicitly name an alternative.

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 intended use is implied: call this when the agent needs Monid's gateway setup, skill file, or remote MCP hops. However, the description gives no explicit when-to-use or when-not-to-use guidance and does not reference any sibling tool as an alternative.

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

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

With no annotations available, the description carries the full burden of behavioral disclosure. It does disclose one meaningful behavior—'No browser is launched'—but it does not explain whether a network request is made, what 'can be opened' means, how failures are reported, or whether the operation is non-destructive beyond the implicit no-browser statement.

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, front-loaded, and contains no filler. Both sentences earn their place: the first states the core purpose and the second clarifies that no browser is launched. It could be more informative, but as a concise statement it is well structured.

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

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

For a tool with nine parameters, no annotations, and no output schema, this description is incomplete. It does not indicate what the tool returns, how the many parameters are used together, what constitutes 'can be opened,' or which sibling tools should be considered instead. The schema compensates for parameter documentation but not for behavioral or usage 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 descriptions cover 100% of parameters, so the baseline is 3 even though the main description does not mention parameters. The description adds nothing about how the URL parameter interacts with other properties like ref, city, json, or path, but those are already individually described in the schema.

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

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

The description clearly states the tool's action and resource: it checks whether a URL can be opened. The added phrase 'No browser is launched' gives a useful qualifier and helps differentiate it from heavy browser-launching tools, though it does not explicitly name any sibling tool or contrast it with fetch-status or playwright-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 about when to use this tool versus alternatives such as fetch-status, normalize-url, or playwright-url-ok. The description does not mention conditions, exclusions, or preferred use cases, leaving the agent to infer when this check is 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 provided, the description carries the full burden of behavioral disclosure. The phrase 'Expression discarded' hints that the expression is not persisted, but it does not state whether the tool is read-only, what it returns, whether it has side effects, or how errors are handled.

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

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

The description is short and front-loaded with the primary action, but it is under-specified. Both sentences are meaningful, yet the lack of parameter mapping and behavioral context means the brevity works against usability.

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

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

This is a 9-parameter tool with no annotations, no output schema, and many siblings. The description is far too sparse to support correct selection and invocation; it does not explain input semantics, return value, or error behavior.

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

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

Although schema description coverage is 100%, the most important concept from the description, the arithmetic 'expression', does not map to any of the nine parameters. The description adds no clarity about which parameter to provide for evaluation, making correct invocation difficult.

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, 'Evaluate a+b style arithmetic', which identifies the tool's core function and distinguishes it from the sibling tools. However, it references an 'expression' that has no corresponding property in the input schema, creating ambiguity about what the tool actually operates on.

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

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

There is no guidance about when to use this tool versus alternatives, no exclusions, and no mention of any prerequisite or context. The phrase 'a+b style arithmetic' implies a basic calculator use case, but the tool cannot be reliably selected based on this alone.

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

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

With no annotations, the description must carry behavioral disclosure, but it only says 'public,' weakly implying read-only access. It does not mention that parameters are discarded, that no arguments are needed, what the tool returns, or any side effects.

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 text is short with no wasted words, but it is under-specified rather than deliberately concise. One six-word noun phrase cannot organize the essential usage and behavioral context for a nine-parameter tool.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, this description is not enough to understand correct invocation. It does not state whether parameters should be supplied, what the record contains, or what the response looks like.

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

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

All nine parameters already have individual descriptions in the input schema, including notes that values are discarded or not accessed. Schema coverage is 100%, so the description does not need to add parameter detail; it adds none but does not need to.

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 is a noun phrase, 'Public ISO 3166-1 record for SY,' with no verb or operation. It mostly expands the tool name cc-sy into country-code record for Syria and never explains what invoking the tool does or how the nine parameters relate.

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 or when to prefer a sibling; no alternatives or exclusions are mentioned. The only implied context is the country-code meaning of SY, which is weak given the generic multi-purpose schema.

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

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

With no annotations, the description carries the burden of disclosing behavior. It does add one meaningful trait: 'Page content is not stored,' which signals a privacy-safe read. However, it omits any detail about network side effects, whether metadata is retained, or response behavior beyond the three return 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?

Two short sentences with the core function front-loaded and a privacy note second. No filler words or redundant restatement.

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

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

For a tool with nine parameters and no output schema, two sentences are thin. The description explains return fields and non-storage, but it does not address why the other parameters exist, how to construct a call, or how this differs from the many sibling URL/status 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 baseline applies even without parameter detail in the tool description. The description highlights URL as the key input but does not clarify the role of the other eight parameters or how they interact; the schema already supplies per-parameter explanations.

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 operation and resource: it returns host, scheme, and HTTP status for a URL. It is clear on its face, but it does not differentiate itself from sibling tools like 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?

No guidance is given about when to choose this tool over siblings such as fetch-status, browser-url-ok, or normalize-url. The only context is the operation itself; no exclusions or alternatives are mentioned.

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

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

With no annotations provided, the description carries the full burden, and it does add a meaningful privacy disclosure ('No identifiers are retained'), reinforced by per-parameter discard notes in the schema ('discarded after the shape check', 'titles discarded'). However, it doesn't disclose other behavioral traits an agent needs, such as whether the call performs network access, whether it is idempotent/read-only, or how errors surface.

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

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

Two sentences with zero wasted words; the purpose is front-loaded and the privacy guarantee is a worthwhile second sentence. It is concise rather than under-specified in length — the problem is semantic vagueness, not wordiness.

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

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

This is a complex multi-input tool with no output schema, no annotations, and 28 siblings, yet the description is only two sentences. It doesn't explain the classification output format, whether inputs are alternatives, what typical responses look like, or how this tool relates to the sibling shape-checkers — an agent would struggle to invoke it correctly beyond passing a random parameter.

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; each of the 9 parameters is already self-documenting with type, purpose, and disposal behavior. The tool description itself adds no parameter-level meaning and does not clarify whether parameters are mutually exclusive alternatives, combinable, or prioritized — a gap the schema doesn't address either.

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

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

The description states a verb and resource ('Show how this request is classified'), which is more than a tautology but remains vague: it never explains what classification system is used, what the output looks like, or what categories exist. Given the 9 heterogeneous inputs (git ref, URL, city, feed, host, JSON, path), the tool's role as a general request classifier is implied but not stated, and it isn't differentiated from the many sibling shape-check tools.

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

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

There is no when-to-use guidance, no exclusions, and no mention of alternatives. With 28 sibling tools including validate-json, normalize-url, domain-shape, file-path-ok, figma-url-shape, and citation, an agent has no way to know whether to call this generic classifier or the specific sibling that matches its input type.

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 the core transformation and disclaims WHOIS/ownership enrichment, but it does not describe the output shape, failure behavior, or whether any network access is involved. This is minimal but not misleading.

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

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

The description is a single sentence with no wasted words. The core behavior and a key limitation are both front-loaded, making it easy for an agent to parse quickly.

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

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

With 9 optional parameters, no output schema, and no annotations, a one-sentence description leaves too much unspecified: which parameter is authoritative, whether parameters can be combined, and what the returned label shape looks like. The schema's inclusion of unrelated fields such as ref, city, feed, json, and path makes the tool's surface area much broader than the description acknowledges.

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

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

Schema coverage is 100%, with each parameter already having a descriptive text, so the baseline is 3. The description adds little about parameters beyond identifying hostname as the object of the operation, and it does not explain how ref, url, city, feed, json, or path relate to splitting a hostname.

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

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

The description states a concrete operation: 'Split a hostname into labels'. The qualifier 'without WHOIS or ownership data' scopes the tool to shape extraction, clearly distinguishing it from domain enrichment or lookup tools. This is specific enough to separate from sibling URL, path, and repo shape tools.

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

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

The description implies use when a caller only needs hostname label segmentation, and the 'without WHOIS or ownership data' phrase signals not to use it for ownership lookups. However, it does not name sibling alternatives or state when the many other schema fields like url, feed, json, or path should be used.

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 does state the essential traits: it issues a HEAD request to a public URL and returns only the status. It does not cover redirect handling, timeout/failure behavior, or the exact status representation, though these are secondary for a read-only HEAD operation.

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 sentence with no filler. It front-loads the method, scope, and output, and every word contributes to the agent's understanding of the tool.

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

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

The tool has nine optional parameters, no annotations, and no output schema, yet the description is a single clause. It does not state which parameter supplies the URL, whether a URL is required despite required=0, or how 'status' is represented in the return value, so the description is not complete enough for reliable invocation.

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

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

The input schema already documents all nine parameters with 100% coverage, so the baseline is 3. The top-level description adds only that the target is a public URL; it does not clarify that the 'url' parameter is the one used for the HEAD request or that the other optional parameters are effectively irrelevant to this operation.

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 HTTP method (HEAD), a resource class (public URL), and the output ('status only'), so an agent can tell this is a lightweight status check rather than a full content fetch. It does not explicitly name or contrast with siblings like web-fetch, but the behavior is otherwise 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?

'Return status only' implies the use case of checking availability or HTTP status without retrieving content, but it gives no explicit when-to-use or when-not-to-use guidance and never mentions alternatives such as web-fetch or browser-url-ok. The agent must infer selection criteria from the method and output 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?

The description discloses one behavior: 'Path discarded.' However, with no annotations present, it should also clarify whether the tool is read-only, what it returns, whether the URL is validated, and that the other schema parameters are effectively irrelevant. 'Parse' alone is underspecified.

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 remarkably concise, with no filler and the action front-loaded. The only structural weakness is that 'Path discarded' is a fragment that could be read as either the URL path or the `path` parameter.

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?

A tool with nine optional parameters and no output schema needs more than two sentences. The description does not state what input to provide, what the tool returns, or what 'shape' means in this context, leaving an agent with significant ambiguity.

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 some Figma-specific meaning to the `url` parameter, but it does not help the agent choose among the many optional parameters. Baseline 3 is appropriate because the schema carries the parameter documentation burden.

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 specific verb and resource: 'Parse a Figma file URL.' This makes the core operation clear. It does not explicitly contrast with sibling URL tools like normalize-url or browser-url-ok, but the Figma-specific resource narrows the intent well.

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 states the operation but gives no guidance on when to choose this tool over alternatives. There is no mention of what to do for non-Figma URLs, generic normalization, or validation, so an agent must infer the appropriate usage.

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

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

'No disk access' is a meaningful behavioral disclosure that goes beyond the schema, telling the agent the check is purely syntactic and has no filesystem side effects. It stops short of defining what counts as 'safe' or describing the return value, but it still provides solid behavioral context for such a concise definition.

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

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

Two sentences with zero waste. The essential claim and the key behavioral constraint are both front-loaded, and every word earns its place. This is a model of concise, structured 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?

The tool's schema contains many unrelated properties, yet the description does not explain their relevance or the fact that they are discarded. It also fails to define what 'looks safe' means or what the tool returns. Sibling tools with clearer scopes make the missing guidance here noticeable, leaving the definition 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?

Every parameter is already described in the input schema, so the description adds nothing parameter-specific, and the high schema coverage gives a baseline of 3. That said, the description does not clarify that the tool presumably operates on the 'path' property and why the other six properties are present, which is an ambiguity that the description could have helped with.

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

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

The description clearly states the action ('Check whether a path looks safe') and adds a distinguishing constraint ('No disk access'), which makes the core purpose understandable. However, the input schema lists seven unrelated parameters (url, city, json, etc.) that are not explained in the description, slightly muddying the overall purpose.

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

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

The description gives no guidance on when to use this tool versus sibling tools such as browser-url-ok, wiki-title-ok, or validate-json. 'No disk access' implies a lightweight syntactic check, but there are no explicit conditions, exclusions, or alternatives mentioned, and the broad schema makes routing worse.

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 carry the behavioral disclosure burden, but it only mentions that Open-Meteo is the backend. It does not disclose external network dependency, rate limits, side effects, failure behavior, or return format, making it insufficiently transparent.

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

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

The description is a single front-loaded sentence with no filler. It efficiently conveys the core purpose and the data source, earning full credit 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?

With no output schema and nine optional parameters, the description is far too thin. It does not specify which parameter represents the place, what the returned coordinates look like, or what happens on failure, so an agent cannot reliably invoke the tool.

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

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

Schema coverage is 100%, but the description does not map 'a place' to any of the nine optional parameters. The only place-like parameter, city, is described as 'discarded after the call', which is confusing and does not help the agent determine which value to supply.

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

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

The description states the tool returns latitude and longitude for a place via Open-Meteo, which clearly identifies the geocoding purpose and distinguishes it from siblings like weather-hint or timezone. It lacks an explicit verb like 'returns' or 'gets', but the intent is still clear.

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

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

No guidance is provided for when to use geo-hint versus alternatives such as weather-hint or normalize-url. There are no exclusion criteria, prerequisites, or context cues, so usage is only implied by the purpose statement.

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 'parse' and does not mention whether other schema parameters are ignored, what the return structure looks like, or how invalid URLs are handled.

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

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

The description is a single, front-loaded sentence with no filler. It is crisp and readable, though slightly undersized relative to the nine-parameter schema and missing 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 no annotations, no output schema, and nine optional parameters, a one-sentence description is incomplete. The description does not explain return format, parameter selection, or edge-case behavior, so an agent has limited guidance beyond the core 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 is 3. The description adds some useful meaning by clarifying that the URL should be a GitHub URL and that owner/repo are the extracted values, but it does not clarify the role of the other eight optional parameters.

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

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

The description clearly states the action ('parse'), the resource ('GitHub URL'), and the expected result ('owner and repo'). This distinguishes the tool from siblings like figma-url-shape, jira-key-shape, and domain-shape, which handle different URL types.

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 GitHub-specific wording implies when to use the tool: when owner and repo need to be extracted from a GitHub URL. However, it does not explicitly name alternatives, state when not to use it, or explain how it compares to similar shape tools.

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

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

No annotations are provided, so the description must carry the behavioral disclosure burden. It only reveals that titles are discarded; it does not disclose whether the tool performs network access, whether it is read-only, what output format is returned, or how the input parameters relate to the count. This is minimal behavioral transparency.

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

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

The description is extremely concise: two short sentences with no filler or repetition. The main action is front-loaded, and 'Titles discarded' is a compact, useful behavioral note.

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

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

The tool has 9 optional parameters, no output schema, and no annotations, so the description must explain how to invoke it correctly. It does not state whether any parameter is required, which parameters are relevant, or what a successful response looks like. The high-level purpose is clear, but the invocation context is incomplete.

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

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

Schema description coverage is 100%, with each of the 9 parameters given a description, so the baseline is 3. The tool description adds no additional parameter meaning and does not clarify which of the many optional parameters, if any, affect the HN front-page count. The schema descriptions themselves are clear but feel disconnected from the tool's stated purpose.

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

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

The description clearly states a specific action and resource: 'Count current Hacker News front-page stories.' The added note 'Titles discarded' clarifies that the result is a count, not a list with titles. It is distinguishable from sibling tools like web-fetch or fetch-status, though it does not explicitly name alternatives.

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

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

There is no guidance about when to use this tool versus alternatives such as web-fetch or normalize-url. The description implies a simple counting use case but provides no context, prerequisites, or exclusions to help an agent choose it confidently.

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

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

With no annotations and no output schema, the description carries the full behavioral burden but only characterizes the data as 'common names' for clock calls. It does not disclose whether the call returns a static list, validates input, accesses the network, or has side effects; the schema hints at 'discarded' inputs, but the description never addresses 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 very short and front-loads the key phrase 'Common IANA timezone names,' with no filler. However, it is a sentence fragment and is under-specified for a tool with nine optional parameters and no output schema, so brevity becomes ambiguity rather than efficiency.

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 required fields, no output schema, and no annotations, the description is not enough to know how to invoke the tool or what a successful call returns. It doesn't clarify whether to call with no arguments, pass zone, or use some other parameter, nor what 'clock calls' means operationally.

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

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

Schema description coverage is 100%, so the schema already documents each parameter, e.g., 'discarded after the shape check.' The tool description adds no parameter-level meaning and does not explain the relationship between the nine optional parameters and the returned timezone 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 identifies the content (IANA timezone names) and domain (clock calls), but uses a noun phrase with no verb—it never says whether the tool returns, lists, or validates those names. It is not a tautology, but it also doesn't clearly distinguish the tool from sibling clock 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?

'For clock calls' implies a use case, so an agent can guess this is a reference for picking timezone names, but there is no explicit when-to-use or when-not-to-use guidance. No alternative tool is named, and the description doesn't explain when to prefer this over timezone or 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, the description carries the full burden. It does meaningfully disclose that the tool fetches a public resource and returns only counts, which signals a read-only, limited operation. However, it does not explain which input selects the target, how failures are handled, or what the count output 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 one concise sentence with the action and output restriction front-loaded. It is easy to scan and contains no filler, though it is arguably terse given the ambiguity in the schema.

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

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

This tool has 9 optional parameters, no required parameters, no output schema, and no annotations, so the description must carry more weight. It does not provide an invocation pattern, return shape, or error behavior, leaving an agent uncertain how to correctly call 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 coverage is 100%, so the base expectation is met by the schema itself. The description adds no guidance on which of the 9 optional parameters to use for the robots.txt fetch; it does not clarify whether url, host, or both should be supplied.

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 ('Fetch'), a resource ('public robots.txt'), and the output ('group counts only'). It is semantically distinct from generic fetch or status tools, but it does not explicitly name or differentiate a sibling tool, so it stops short of a 5.

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

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

There is no guidance about when to use this tool versus alternatives like web-fetch or fetch-status. The 'only' qualifier hints at scope, but no conditions, exclusions, or alternative tool references are provided.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does mention that the key is 'discarded', which is a useful side-effect clue, but it does not state what the tool returns, whether it performs any external access, or how it signals validity. That is too little for a no-annotation tool.

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 text is very short, front-loads the core purpose, and contains no padding. Both sentences add something: the first states what the tool does, and the second notes a behavioral side effect. The structure is efficient, even if the content is under-specified.

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

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

For a tool with nine optional parameters, no output schema, and no annotations, this description is far from complete. It fails to identify which parameter carries the Jira key, what the valid shape grammar is, or what the caller should expect in return. An agent would likely need to guess or inspect other signals.

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

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

Although schema coverage is 100%, the nine parameter descriptions describe unrelated domains—URLs, city names, feeds, JSON, paths, timezones, and query text—and none is explicitly the 'Jira key' the tool claims to check. The description provides no mapping from the tool's purpose to any schema property, so an agent cannot confidently choose which parameter to populate.

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 ('Jira issue key') and a specific action ('check ... shape'), which distinguishes it from sibling shape-checking tools like github-repo-shape or domain-shape. However, it never defines what a valid Jira key shape is, leaving the expected input format unclear.

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

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

No guidance is provided about when to use this tool versus alternatives such as normalize-url, file-path-ok, or the other -shape tools. There are no conditions, exclusions, or routing cues to help an agent choose 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?

With no annotations provided, the description carries the burden of explaining behavior. It does disclose that only the HTTP status is returned and that the response body is discarded, which is useful. But it does not mention redirects, timeouts, error behavior, or whether any network side effects occur, leaving moderate gaps.

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

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

The description is two short sentences with no wasted words. It front-loads the main purpose and then states the key constraint. This is appropriately concise for a simple status-check tool.

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

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

Given nine optional parameters, no annotations, and no output schema, this description is under-specified. It does not explain which parameters are relevant, how the docs URL is assembled, or what the HTTP status response looks like. An agent would likely struggle to call this tool correctly without additional information.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description itself adds no parameter-level guidance and does not clarify which of the nine optional parameters should be used to form the docs URL. Each parameter already has its own schema description, so the description is not required to compensate, but it also does not enhance selection.

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 operation—returning an HTTP status for a public library docs URL—and adds the useful constraint that the body is discarded. It is clear and distinct from generic 'fetch' or 'check' tools, though it does not explicitly contrast itself with sibling tools like fetch-status or web-fetch.

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

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

The phrase 'Body discarded' implies that this tool is for situations where only the HTTP status is needed, not page content. However, it never names alternatives or states when not to use this tool, so the usage guidance remains implicit rather than explicit.

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

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

With no annotations, the description carries the full burden and does add useful behavior: values are discarded and only the key count matters. It does not disclose output format or side effects, but the operation is simple and read-only in nature.

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

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

Two short sentences with no filler; the core action is front-loaded and the value-discarding caveat is placed right after. 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 description is too thin for a tool with 9 optional parameters and no output schema. It does not specify which parameter should carry the JSON object, what the return value looks like, or that all other parameters are irrelevant.

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

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

Schema coverage is 100%, so each parameter already has a clear description; the baseline is therefore 3. The description adds a general value-discarding rule but does not explain how to supply the 'JSON object' given the schema only exposes individual string fields.

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

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

The description states a concrete operation—count keys in a JSON object—and adds that values are discarded, so an agent knows what the tool does and what it ignores. It is not a tautology and is distinct in scope from a validator like validate-json, though it does not explicitly name alternatives.

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

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

No guidance is given about when to choose this tool over the many siblings. The only hint is the tool's own semantics, which is not enough for routing decisions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does disclose a meaningful, non-obvious behavior: query and fragment are dropped, and only origin, host, and path are returned. It does not cover invalid-input handling, but the core side-effect-free behavior is transparent.

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 primary behavior and followed by the key exclusion. Every word earns its place, and there is no redundant restatement of the tool name or schema details.

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

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

For a simple URL normalization task, the core behavior is described, but the tool exposes 9 parameters and has no output schema, leaving ambiguity about return format and how to handle the non-URL parameters. The schema fills much of this gap, but the description alone is only minimally complete for such a broad parameter surface.

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 input schema already explains every parameter, including which ones are discarded after checks. The description adds the URL context but does not clarify why the schema contains many unrelated-looking parameters; the schema's per-parameter notes handle that adequately.

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

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

The description clearly states the operation: 'Return origin, host, and path for a URL' and adds the specific behavior that query and fragment are dropped. It does not explicitly distinguish itself from sibling URL-oriented tools like domain-shape or figma-url-shape, but the resource and action are 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?

The description implies the tool should be used when a caller needs URL origin, host, and path components, and the `url` parameter in the schema supports this. However, there is no explicit guidance about when to prefer this tool over siblings such as browser-url-ok or fetch-status, and no exclusion criteria are stated.

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

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

The description provides one useful behavioral fact—'No browser is launched'—which helps distinguish it from browser automation. However, it does not disclose that most input parameters are discarded after a shape check, that the tool may not actually contact the URL, or what 'openable' means in practice. With no annotations to carry the safety/behavioral profile, the description leaves significant uncertainty.

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 two sentences are concise and front-load the core action. Yet the description is under-specified for a tool with seven heterogeneous parameters, so while it has no fluff, it is not appropriately sized to convey the tool's real complexity.

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

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

The description omits essential context: what 'openable' means, how the multiple input fields (ref, city, feed, json) relate to the check, what the output/return value looks like, and how it differs from nearby siblings. Given the parameter richness and absence of annotations, this is far from complete.

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

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

The description adds no parameter-level meaning; the schema already describes each parameter, but its wording ('discarded after the shape check') conflicts with the description's 'can be opened' phrasing. This mismatch muddles whether the tool is a URL-opener or a shape validator, making it harder for an agent to correctly interpret the parameters.

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

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

The description states a clear action ('Check whether a URL can be opened') and a distinguishing behavioral note ('No browser is launched'). It names the resource (URL) and the verb (check), which is enough to understand the core purpose. However, 'can be opened' is somewhat ambiguous—it could mean syntax validation, DNS resolution, or HTTP reachability—so it doesn't fully resolve the intent.

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, fetch-status, or normalize-url. The description does not mention any exclusions, prerequisites, or alternative conditions, leaving the agent to infer the tool's placement among neighboring tools.

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

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

With no annotations provided, the description carries the full burden of disclosure. It usefully states that the query is discarded, implying no raw data is returned or retained. However, it does not disclose the exact return format or behavior when the query is missing or when multiple parameters are supplied.

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

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

The description is two short sentences with no filler. The core action is front-loaded, and the discard note adds a relevant behavioral detail without bloating the 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 has no output schema and no annotations, yet the description never explains what is returned (e.g., a number, JSON object, or success indicator). It also does not clarify which of the nine optional parameters is relevant or what happens if the query parameter is omitted, leaving an agent with significant uncertainty.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds little parameter-level meaning beyond mapping 'search query' to the 'query' parameter, which is acceptable as a baseline but not a strong supplement.

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

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

The description states a specific verb and resource: count characters in a search query. The phrase 'Query discarded' clarifies that the query itself is not returned. It is implicitly distinct from sibling shape/validation tools, though it does not explicitly name any alternative.

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

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

No guidance is provided about when to use this tool versus sibling tools like fetch-status, normalize-url, or validate-json. The description does not state prerequisites, exclusions, or conditions that would route an agent here.

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

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

Without annotations, the description must disclose behavior itself, but it only labels the tool a 'catalog'. It does not state whether the call is read-only, whether inputs are discarded, whether any network/disk access occurs, or what the returned data looks like. The schema-level notes about discarded values are not in the description and do not compensate for the missing 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 text is short, but it is under-specified rather than efficiently concise. A single sentence that simply restates the tool name does not earn its place as a standalone 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?

For a tool with nine parameters, no annotations, and no output schema, the description is far too minimal to let an agent call it correctly. It fails to explain how the catalog relates to the supplied URL, city, feed, host, json, path, zone, query, and ref inputs, and it never describes the response.

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

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

With 100% schema description coverage, the baseline is 3. The description adds no parameter semantics of its own, but each of the nine optional parameters already has a meaningful schema description (e.g., ref is 'discarded after the shape check', json is 'JSON text to validate').

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 'Short catalog of common HTTP status codes' essentially restates the tool name 'status-catalog' and supplies no verb or action. It does not say whether the tool lists, looks up, validates, or returns status codes, and it gives no information that would distinguish it from siblings like fetch-status or compatibility.

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

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

There is no guidance about when to use this tool rather than an alternative. The description does not mention conditions, exclusions, or any relationship to fetch-status, web-fetch, or other siblings; usage has to be guessed from the name alone.

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

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

Despite having no annotations, the description discloses the critical behavioral trait that the prompt is discarded, implying a stateless, template-returning operation. It could also state that all input fields are ignored, but the parameter descriptions reinforce the discard behavior.

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

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

The description is extremely compact: one sentence states the output and one sentence states the key behavioral constraint. No filler or redundant restatement of the tool name or schema appears.

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 adequate for a trivial template-returning tool, but it never specifies what the 'three-step thinking template' consists of or why seven unrelated parameters exist in the schema. Since there is no output schema, a little more detail about the template shape would have improved completeness.

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

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

The input schema already describes every one of the seven parameters in detail, so schema coverage is high. The tool description adds no extra parameter meaning beyond the global 'Prompt discarded' hint that inputs are not used in generating the template.

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 specific verb ('Return') and identifies a concrete resource ('three-step thinking template'), making the primary action clear. The added 'Prompt discarded' sentence also signals that this is not a prompt-processing tool, which helps distinguish it from many analysis tools in the sibling list.

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 usage case is only implied: the tool is appropriate when a fixed thinking scaffold is needed rather than actual analysis, since 'Prompt discarded' indicates no input is processed. It does not explicitly state when not to use it or name the alternative tools.

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

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

No annotations are provided, so the description carries the disclosure burden. It at least implies a read-only time lookup, but it does not disclose output format, behavior for invalid timezone names, or whether the timezone parameter is required in practice.

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

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

The description is a single succinct sentence with no filler. The operation and resource are clearly front-loaded.

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

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

For a tool with nine schema parameters and no output schema or annotations, this one-sentence description is incomplete. It does not say which parameter to pass, what the returned time looks like, how errors are handled, or when to prefer sibling tools.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds no parameter-level meaning and does not clarify that the relevant parameter is timezone among many unrelated-looking schema fields, but the high coverage yields a baseline score of 3.

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 operation ('Current time') and resource ('named IANA timezone'). This differentiates it from likely siblings like utc-time and iana-zones without being vague or circular.

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 choose this tool over alternatives. It does not mention utc-time, iana-zones, or any exclusions, leaving usage entirely implicit.

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, but it only says 'Current UTC timestamp.' It does not disclose that the nine parameters appear to be irrelevant to the actual operation, nor does it describe the output format or confirm the operation is read-only and side-effect-free.

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

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

The description is a single clear sentence with no filler, making it very concise and front-loaded. It is not as egregiously under-specified as a tautology, though more structural context about the parameters would improve usefulness.

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 given the tool's unusual schema: it does not explain why utc-time accepts nine unrelated optional parameters, does not specify the return format, and does not clarify whether the parameters are ignored. In the absence of an output schema, this is a notable gap for an agent trying 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?

Schema description coverage is 100%, so the baseline is 3. The description text adds no parameter semantics, but the schema already provides detailed (if odd) descriptions for each parameter, including notes like 'discarded after the shape check' and 'no disk access.'

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

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

The description clearly states that the tool returns the current UTC time as a timestamp, which distinguishes it from sibling tools like timezone and iana-zones. However, it lacks a verb and does not specify the timestamp format (e.g., Unix epoch vs ISO 8601), so it is not a perfect 5.

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

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

The description gives no explicit guidance on when to use this tool versus siblings such as timezone or iana-zones. It does not mention that the many input parameters are ignored, 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?

No standard annotations are provided, so the description carries the full burden. It discloses one behavioral trait: the input body is discarded after checking. However, it does not mention return value, error behavior, or potential side effects. The disclosure is minimal but present, earning a 3.

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. It front-loads the core purpose and immediately adds the discarding detail, making it highly efficient and well-structured.

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

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

The core function is described adequately, and the required 'json' parameter is clear from the schema. However, the schema contains six other parameters that are not explained in the description, and there is no mention of the return format or error handling. For a simple validator, this is acceptable but not fully complete.

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

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

The input schema has 100% description coverage, so the baseline is 3. The description does not add parameter-specific meaning beyond the schema; it only refers to 'body' while the actual parameter is 'json'. The schema descriptions (e.g., 'discarded after the check') already explain the parameters, so the description adds no extra value.

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

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

The description states a specific verb and resource: 'Check whether a body is valid JSON.' This clearly identifies the tool's function and distinguishes it from sibling validators like domain-shape or github-repo-shape. The 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?

The description implies when to use the tool (when JSON validation is needed) but does not explicitly compare it to alternatives. The phrase 'The body is discarded' hints that this is for validation only, not for extracting or using the content, but no when-to-use or when-not-to-use guidance is given.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only names the external service and the data returned. It does not explain that several schema parameters are discarded, what happens on invalid or missing input, or whether this is a real API call versus a fixed hint.

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

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

The description is a single, front-loaded sentence with no filler. It communicates the essential purpose efficiently and every word contributes to the meaning.

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

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

Given nine parameters, zero annotations, and no output schema, this one-line description is not complete enough. It does not tell the agent which parameters matter, how to handle the discarded fields, or what a successful response looks like.

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 tool description adds only the implication that 'city' is the relevant input, but it does not clarify the role of the other eight parameters or confirm they are ignored.

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

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

The description clearly states the tool's core function: returning the current temperature for a city via Open-Meteo. It is specific about the resource and provider, and the 'weather' focus distinguishes it from siblings like geo-hint and timezone, though it does not explicitly call out sibling differences.

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 explicit guidance about when to use this tool instead of alternatives like web-fetch or geo-hint, and no mention of when it should not be used. The only implied usage is 'for a city temperature,' which the reader must infer.

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 burden of behavioral disclosure. It does reveal a key behavior: only status and content type are returned, and the body is discarded. But it does not mention redirects, timeouts, normalization, or that the many non-URL schema parameters are discarded, leaving important behaviors 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 two short sentences with no filler. The main result is front-loaded and the second sentence adds a meaningful behavioral constraint without waste.

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

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

Despite high schema coverage, the tool has nine optional parameters, no output schema, and no annotations. The description does not tell an agent which parameter to populate, what the response format looks like, or why most parameters are described as 'discarded,' leaving significant ambiguity 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 even though the description adds almost no parameter-level detail. The description aligns 'public URL' with the `url` parameter, but it does not clarify why the other eight optional parameters exist or how they interact with the fetch.

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

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

The description clearly states that the tool reports HTTP status and content type for a public URL and explicitly notes that the body is discarded. It is specific enough about the resource and result, though it does not differentiate itself from siblings like fetch-status or browser-url-ok.

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

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

The constraint 'public URL' and the note 'Body discarded' imply this is for lightweight header/status checks rather than body retrieval. However, no alternatives are named and there is no explicit when-to-use or when-not-to-use 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?

There are no annotations, so the description carries the full behavioral burden. It discloses that the title is 'discarded after the call,' implying no retention, but it does not explain the output, error behavior, or whether the check performs a live network call. This is too sparse for a tool with no annotation support.

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

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

The description is concise at two sentences and front-loads the primary purpose. The second sentence adds a behavioral note. While the 'title discarded' phrasing is confusing given the schema, the overall structure is efficient with no wasted words.

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 seven schema parameters and no output schema, the description is completely inadequate. It fails to explain which parameter supplies the title, what success or failure looks like, or how this tool relates to its siblings. An agent would not be able to call this tool correctly based on the provided definition.

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

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

The input schema has 100% description coverage, which normally gives a baseline of 3. However, the description references a 'title' parameter that does not exist in the schema; the schema instead lists unrelated parameters like ref, url, city, feed, host, json, and path. This contradiction actively confuses parameter selection rather than adding meaning.

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

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

The description states a specific action: 'Check whether a Wikipedia title exists.' This clearly identifies the tool's purpose and resource. However, it does not distinguish it from sibling tools, and the input schema does not contain a title parameter, which slightly undermines the 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?

The description implies usage: use this tool when you need to check Wikipedia title existence. But it provides no explicit guidance about when not to use it, no alternatives, and no context for selecting it over related validation tools such as browser-url-ok or domain-shape.

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