ISO country ST

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

With no annotations, the description carries the full behavioral burden. It does disclose the return categories and that task text is discarded, and 'pay-per-call' hints at cost sensitivity. However, it does not explain whether outbound hops occur at call time, whether inputs affect the result, or what cost/error behavior to expect.

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 three short, front-loaded sentences with no filler. It states the action first, then the returns, then the key caveat, making it easy to scan and act on.

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 no annotations, no output schema, and several optional-looking parameters, the description lists returns but not their shape or how to invoke the tool (e.g., with zero arguments or with a particular parameter). It is minimally adequate but leaves an agent guessing about the call contract and payload structure.

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 and the description does not need to enumerate parameters. The description adds no parameter-level meaning; the 'task text discarded' note does not map to any specific schema property.

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 opens with a concrete action and resource: 'Find a public pay-per-call tool gateway (Monid)' and then lists specific deliverables such as CLI setup, skill file, and remote MCP hops. This gives the tool a distinct identity among the many validation/fetch siblings, though 'Monid' itself is left unexplained.

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 you need Monid's setup or routing information. The warning that task text is discarded is a useful exclusion, but no sibling alternatives or explicit when-to-use/when-not-to-use conditions 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 must carry the behavioral burden, and it does disclose one meaningful trait: no browser is launched. However, it does not explain what 'can be opened' means operationally, whether a network request is made, how redirects or failures are handled, or what the return format is.

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

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

The description is one efficient sentence with zero filler. The core check is front-loaded and the key caveat follows immediately, so 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 parameters, no output schema, and no annotations, yet the description only says a URL is checked and no browser is launched. It fails to explain the return value, the role of the many seemingly unrelated parameters (e.g., ref, city, json, path), and the intended use case, leaving a caller uncertain 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%, so the baseline is 3. The tool description adds no parameter-specific meaning, but the schema already documents all 9 parameters, so no compensation is needed.

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 the explicit verb 'check' with a clear resource ('whether a URL can be opened'), stating exactly what the tool does. The added negation 'No browser is launched' clarifies the operational scope and helps differentiate it from browser-based siblings like 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?

The description gives no guidance on when to use this tool versus alternatives such as web-fetch, fetch-status, or playwright-url-ok. It hints at a lightweight check via 'No browser is launched' but never states explicit conditions, exclusions, or preferred scenarios.

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 'Expression discarded,' which hints at non-persistence but does not describe side effects, return values, or what happens to the nine actual schema parameters. The behavioral claim is also confusing because 'expression' does not map to any parameter in the schema.

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

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

The text is short and front-loaded, which is structurally good. However, the second sentence 'Expression discarded' is cryptic and references a parameter that does not exist, making it wasted and counterproductive. It is concise in length but not in informative value.

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 grossly inadequate. It omits return value, side effects, invocation context, and any connection between the schema parameters and the claimed arithmetic behavior. An agent cannot correctly select or invoke the tool based on this 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?

Schema coverage is 100%, so a baseline of 3 would normally be appropriate, but the description adds no parameter-level meaning and instead introduces a non-existent 'expression' concept. This actively undermines the schema's otherwise adequate parameter descriptions rather than enhancing them.

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

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

The description states 'Evaluate a+b style arithmetic. Expression discarded,' which at first names a verb and resource, but the input schema contains no expression parameter. Instead it lists ref, url, city, feed, host, json, path, zone, and query, each described around shape checking or discarding. The stated purpose is therefore misleading about what the tool actually accepts and does.

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

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

No guidance is given about when to use calc-eval versus siblings such as domain-shape, validate-json, or normalize-url. There are no conditions, exclusions, or alternatives mentioned. An agent cannot infer the appropriate context for this tool.

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 says nothing about side effects, read-only guarantees, return behavior, failure modes, or any other runtime behavior. 'Public' is too weak to establish that the tool is safe or non-mutating.

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 single sentence is concise, but it is under-specified rather than effectively structured. It leaves all operational substance to the schema and does not earn its place as a usable 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?

With nine optional parameters, no output schema, and no annotations, this description is far too thin. It omits what the tool returns, which inputs matter, how they interact, and how this tool relates to the large set of sibling utilities.

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, giving a baseline of 3. However, the description itself adds no parameter meaning and does not explain which parameters are relevant to the ISO 3166-1 record or how they should be combined.

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 ('ISO 3166-1 record for ST') but does not state a verb or operation, so it is unclear what the tool actually does. It also fails to relate the described purpose to the nine unrelated-looking parameters, and does not distinguish the tool from its siblings.

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, what conditions apply, or how it differs from alternatives like normalize-url, validate-json, or timezone. The phrase 'Public ... record' implies availability but not invocation 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?

The 'Page content is not stored' note is a real behavioral disclosure, especially given no annotations, and it is helpful for an agent worried about privacy or side effects. However, with no annotations, the description carries the full burden and leaves other relevant behaviors—network request behavior, error/rate behavior, and whether other inputs are retained—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?

Two short sentences with no filler; the first sentence front-loads the operation and outputs, and the second adds a meaningful retention caveat. The structure is appropriately sized for the core message.

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 nine optional parameters, no annotations, no output schema, and a large sibling set, the description covers only one narrow URL operation and a single retention fact. It omits when to use the tool, what the other parameters are for (relying entirely on schema names), and what the returned host/scheme/status structure looks like, so it is incomplete for the tool's actual 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%, so the input schema already documents each of the nine optional parameters and their discard behavior; the description adds little beyond the URL focus. It does not explain how the parameters relate to the stated URL operation, but the baseline of 3 applies because the schema handles the semantics.

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

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

The description clearly states a specific operation—return host, scheme, and HTTP status for a URL—and even clarifies that page content is not stored. It is clear and likely distinguishable from siblings like web-fetch by the no-storage note, but it never explicitly names or contrasts an alternative, so it stops short of full 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?

There is no guidance about when to choose this tool over the many URL-related siblings (fetch-status, normalize-url, web-fetch, browser-url-ok). The description implies a URL check/citation use case, but it does not provide selection criteria or exclusions.

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

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

The description discloses one useful trait: 'No identifiers are retained.' However, it does not explain how classification is performed, whether inputs are sent externally, what the tool returns, or what side effects may occur. With no annotations, this is insufficient for a tool handling URLs, paths, JSON, and identifiers.

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 no filler words. However, the compression omits necessary context for a tool with nine optional parameters, so it reads as under-specified rather than optimally concise.

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

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

With nine optional parameters, no output schema, and no annotations, this one-sentence description does not give an agent enough to predict return values, required input combinations, or behavior. The privacy reassurance is helpful but does not compensate for the missing classification details.

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 itself adds no meaning about how the many optional parameters relate to classification, but each parameter is already individually documented 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 says 'Show how this request is classified,' which is a verb plus object, so it is not a pure tautology. However, 'classified' is undefined: no categories, no result format, and no link to the nine schema fields are provided. Sibling tools like validate-json, normalize-url, and citation make the intended scope ambiguous.

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

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

No guidance is given about when to use this tool versus siblings such as validate-json, normalize-url, citation, or the various shape-check tools. The privacy note hints at a use case, but it does not state conditions, exclusions, or alternatives.

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

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

No annotations are provided, so the description carries the behavioral transparency burden. It does disclose that the operation is a pure split with no WHOIS/ownership data involved, which is useful. However, it does not describe the return format, possible validation behavior, or any side effects or network 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 focused sentence with no filler. It front-loads the core operation and adds the key exclusion ('without WHOIS or ownership data') economically.

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

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

The definition is incomplete relative to the tool's actual surface area: the schema exposes nine optional parameters including city, feed, json, path, and url, none of which are explained in the description. There is no output schema, and the description does not clarify what the tool returns or which parameters are relevant for a hostname split, 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 parameter descriptions already document each field. The tool description adds only that the operation concerns a hostname, which loosely maps to the 'host' parameter, but it does not add meaningful parameter semantics 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 uses a specific verb ('Split') and resource ('hostname') and adds a useful scope limitation ('without WHOIS or ownership data'). It clearly states what the tool does, though it does not explicitly differentiate it from sibling URL/shape tools.

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

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

The phrase 'without WHOIS or ownership data' implies a boundary on the tool's behavior and gives some context about when it is appropriate. However, it does not mention sibling alternatives or provide explicit when-to-use/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?

The description discloses the HTTP method (HEAD) and the narrow return scope ('status only'), which is useful because no annotations are provided. However, it does not explain redirect behavior, authentication requirements, error handling, or how the many schema parameters are treated or discarded.

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. Every word contributes to the core behavior.

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

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

Despite being concise, the description is insufficient for a tool with 9 optional parameters, no output schema, and no annotations. It does not explain which parameter to provide, what happens with the other parameters, or what status values can be returned.

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 schema. The description adds no parameter-level meaning beyond naming 'a public URL,' so the baseline score of 3 is appropriate.

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

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

The description states a specific action: 'HEAD a public URL and return status only.' This clearly identifies the tool as a status-checker and distinguishes it from content-fetching tools like web-fetch. However, the input schema lists many non-URL parameters (city, zone, query, json, path), so the description does not fully clarify which inputs are actually relevant.

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 siblings such as browser-url-ok, playwright-url-ok, or web-fetch. The phrase 'status only' implies a lightweight HEAD check, but no alternatives or exclusion conditions 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 or output schema, the description carries the full disclosure burden, yet it only discloses that 'Path discarded'. It does not state whether the call is read-only, what the parsed result looks like, or whether query/hash components are also removed, leaving important behavior for the agent to infer.

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 front-loads the core intent with no filler. It loses a point because 'Path discarded' is telegraphic and could be rewritten as a complete statement of the transformation.

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 required fields, no output schema, and no annotations, yet the description provides only a one-line purpose. It omits which parameter to populate and what happens for invalid or non-Figma URLs, so an agent has significant gaps to fill before calling it confidently.

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

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

Schema description coverage is 100%, so the baseline applies; property descriptions such as 'HTTPS URL to normalize or cite' and 'discarded after the shape check' provide some meaning. Yet the description itself adds no mapping between the Figma URL and the nine optional parameters, and fields like city, feed, and zone appear unrelated, so it does not exceed 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 names a concrete verb and resource ('Parse a Figma file URL') and distinguishes the tool from sibling shape checkers such as github-repo-shape and jira-key-shape by the URL type. It stops short of 5 because 'parse' is underspecified and 'Path discarded' is a fragment rather than a full statement of what is produced.

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 clearly: choose this tool when a Figma file URL needs to be parsed. However, there is no explicit when-not guidance or routing relative to URL siblings like normalize-url, browser-url-ok, or playwright-url-ok.

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. 'No disk access' is a useful behavioral disclosure indicating a non-IO safety check, but the description does not state what the tool returns, what 'looks safe' means, or whether any other 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 very concise: two short sentences with no filler, and the key scoping statement is front-loaded. However, given the nine-parameter schema, the terseness comes at the cost of useful 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?

There is no output schema and no annotations, so the description must explain return behavior and usage context, but it does not. It also leaves unclear whether the non-path parameters are valid inputs, and with zero required parameters, an agent cannot tell what a valid call 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 the schema already documents all nine parameters. The description adds no parameter-specific meaning and does not clarify how the 'path' parameter relates to the other unrelated fields 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 states a clear verb and resource: checking whether a path looks safe. However, the input schema exposes eight other parameter types (url, json, city, feed, host, ref, zone, query) that the description does not account for, so the stated purpose does not reliably map to the tool's full interface.

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 on when to use this tool versus siblings like browser-url-ok or wiki-title-ok. The term 'path' implies a file-path context, but no conditions, exclusions, or alternative routing 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, but it only says latitude and longitude are produced via Open-Meteo. It does not mention that external network calls may occur, which parameters are actually used or ignored, whether results are cached, or how failures are handled. Some parameter descriptions mention values being discarded, but the main description does not clarify the tool's overall behavior.

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

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

The description is a single concise sentence with no filler or repetition. It is front-loaded with the core purpose. However, it is so brief that it omits critical operational structure, such as which parameter is relevant and what the output looks like.

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 optional parameters, no output schema, no annotations, and a large sibling set, a single sentence is far from complete. The description does not explain which parameter identifies the place, whether multiple parameters can be combined, or what the result format is. An agent cannot confidently invoke this tool 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?

Although schema description coverage is 100%, the tool description does not indicate which parameter supplies the 'place' for geocoding. The 'city' parameter is described as being for a 'public weather hint', not for latitude/longitude lookup, creating confusion. The description adds no value beyond the schema for selecting or filling parameters 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 clearly states the tool provides latitude and longitude for a place, with a specific external source (Open-Meteo). It is not merely a tautology and is distinguishable from weather- or time-related siblings by the geospatial focus. However, it lacks an explicit verb and does not explicitly differentiate from sibling tools.

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

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

There is no guidance on when to use this tool versus alternatives such as weather-hint or timezone. No context is given about prerequisites, when this should be preferred, or when another sibling should be used instead. The description leaves the agent to infer usage entirely.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says only 'Parse owner and repo from a GitHub URL' and does not explain what the tool returns, how invalid GitHub URLs are handled, whether parsing failures produce errors, or whether the tool only validates rather than extracts. The schema's repeated 'discarded after the check' hints at a validation behavior, but the description itself is too thin.

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

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

The description is a single, focused sentence with no filler. It front-loads the essential action and object, and every word contributes to the 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?

Despite the concise phrasing, the tool has nine optional parameters, no annotations, and no output schema. The description does not indicate which parameter to pass, what the return shape is, or how this tool fits among many sibling shape tools. An agent would likely struggle to invoke it correctly without guessing.

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

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

The schema has high description coverage for all parameters, so the baseline is 3. The description adds some meaning by implying that 'url' is expected to be a GitHub URL, but it does not clarify the relationship between the nine optional parameters, which one is the actual input, or why unrelated parameters like 'city', 'feed', and 'query' exist. The schema descriptions are generic and the tool description does not compensate for that confusion.

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

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

The description uses a specific verb ('Parse') and identifies the resource ('owner and repo from a GitHub URL'), so the core purpose is clear. However, it does not differentiate this tool from sibling shape-related tools such as figma-url-shape or jira-key-shape, so some ambiguity remains in the broader toolset.

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?

Usage is implied: an agent should call this when it needs owner and repo parsed from a GitHub URL. There is no explicit guidance about when not to use it, no mention of which parameter to populate, and no comparison to alternative sibling tools, making the usage context only minimally 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?

The phrase 'Titles discarded' is a genuine behavioral disclosure: the tool returns a count and omits story titles. However, with no annotations provided, the description still does not explain whether this performs a live network fetch, what happens on failure, or that it has no side effects, so the transparency burden is only partially met.

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 main action; every word earns its place. This is exemplary conciseness, even though the resulting brevity may be insufficient for the confusing 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?

For a tool with nine optional parameters and no output schema or annotations, a two-sentence description is incomplete. It fails to state that all arguments are likely discarded, to define the exact return type, or to describe error behavior, so an agent cannot confidently 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; each parameter has a one-line description. The tool description itself adds no parameter-level meaning and does not clarify why parameters like url, host, or path are present, leaving their relevance ambiguous.

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

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

The description uses a specific verb ('Count') and a clear resource ('current Hacker News front-page stories'), and adds that titles are discarded, so an agent knows the output is a numeric count rather than a list of stories. It does not explicitly compare with sibling tools, but none of the listed siblings cover the same HN-counting function.

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 about when to use this tool versus web-fetch, fetch-status, or other siblings, and it never mentions that the nine schema parameters are optional or likely irrelevant. This makes it easy for an agent to over-supply unrelated arguments like url, feed, or path.

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 states the subject matter. It does not explain that this appears to be a no-argument catalog, that most parameters are discarded, or what the return value 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 a single, efficient phrase with no wasted words and the core subject is front-loaded. It earns a 4 for conciseness, though the brevity comes at the cost of explanatory content.

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

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

The tool has nine optional parameters, no output schema, and no annotations, so the description is under-specified. An agent cannot tell whether to call it with no arguments, whether the zone parameter is meaningful, or what output to expect.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds little beyond the schema: it loosely connects the tool to clock calls but does not clarify which of the nine parameters, if any, affect the result.

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 resource ('common IANA timezone names') and the general context ('for clock calls'), but it lacks an action verb such as 'returns' or 'lists.' An agent can infer the subject matter but cannot tell whether the tool provides a list, validates a name, or performs some other operation.

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 'for clock calls' gives an implied usage context, suggesting this tool is related to timezone/clock operations. However, it does not name sibling tools like timezone or utc-time, and it gives no explicit guidance on when to choose this tool over alternatives or when not to use 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?

With no annotations, the description carries the behavioral disclosure burden. It does disclose that this is a read-only public fetch and that the return will be limited to group counts. It does not disclose behavior on missing robots.txt, redirects, or which related parameters are actually used.

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 front-loaded sentence with no filler. The verb, resource, and output constraint are all packed efficiently.

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

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

The tool takes 9 optional parameters with no required fields and no output schema, yet the description doesn't identify which parameter supplies the robots.txt target. An agent invoking it would have to guess between 'host', 'url', and possibly others, making the definition incomplete for successful 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 description does not map its single action to any of the 9 parameters (host, url, etc.), but the schema itself already describes each parameter. There is no extra meaning added by the description beyond the intended resource.

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 verb ('Fetch'), a specific resource ('a public robots.txt'), and a precise output ('group counts only'). This differentiates it from siblings like web-fetch and fetch-status, which are general-purpose fetchers.

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 'robots.txt' and 'group counts only' wording implies when to use it: when only a summary count of robots.txt groups is needed, not the full content. However, there is no explicit when-not-to-use guidance or comparison with siblings such as 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?

No annotations are present, so the description carries the full burden of behavioral disclosure. It does say 'Key discarded,' which hints that input is not retained, but it never states what the tool returns, how it signals an invalid shape, whether it performs any external lookup, or what happens on failure.

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 free of filler: the first sentence states the action and the second notes an important side effect. It is concise, though it borders on under-specification.

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 nine-parameter tool with no output schema and no annotations, this description is far from complete. It does not say which parameter holds the Jira key, what valid shape means, what the return value represents, or how this tool relates to the many sibling shape-checking 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 each parameter already has its own description and the baseline is 3. The tool description adds no parameter-level information and does not map the 'Jira issue key' concept to any specific schema property, leaving ambiguity about which of the nine parameters should carry the key.

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 ('Check') and resource ('Jira issue key shape'), which helps distinguish it from sibling shape tools such as domain-shape or github-repo-shape. However, 'shape' is never defined, so the agent does not learn what a valid Jira key shape actually is; the description largely restates the tool name.

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

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

No when-to-use or when-not-to-use guidance is provided. The description does not mention alternatives, exclusions, or the conditions under which this tool should be chosen over similar shape-checking siblings. Any usage context must be inferred entirely from the tool name.

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 transparency. It does disclose one important behavior: the body is discarded, so only status matters. But it does not mention network behavior, error handling, redirects, or whether other parameters are ignored, which leaves room for agent 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 description is extremely concise: two short fragments, no filler, and the key behavior is front-loaded. It earns its place, though it may be too terse given the tool's 9 optional parameters and absent output 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?

For a tool with 9 optional parameters, no annotations, and no output schema, the description is not complete enough. It fails to specify which parameter matters, what to pass, or how to interpret edge cases. The statement 'Body discarded' helps, but it does not compensate for the lack of guidance on selecting among the many schema properties.

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 adds no parameter-level meaning; it does not even indicate that the `url` parameter is the primary input. The schema descriptions are present but somewhat inconsistent with the stated purpose, referencing 'normalize or cite' rather than checking status.

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 indicates the tool returns an HTTP status for a URL and that the body is discarded. The phrase 'public library docs URL' narrows the resource somewhat, though 'public library docs' is ambiguous and does not explicitly distinguish this from sibling tools 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 context is implied: use this when you need an HTTP status for a public library docs URL rather than its content. However, there is no explicit when-to-use vs alternatives, no named sibling tools, and no exclusion such as 'for general URLs use fetch-status instead.'

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 that values are discarded, which is useful and implies a non-mutating, read-only operation. But it does not mention the return format, edge cases like empty objects, or whether the count is top-level only, leaving some behavioral 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 description is exceptionally concise: two short sentences with no filler. The core action is front-loaded, and the second sentence adds meaningful information about value handling without redundancy.

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

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

Given the simple nature of the tool and the 100% schema coverage, the description is minimally viable. However, with no output schema and no explicit statement of the return value, plus ambiguity about whether the count applies to the fixed input object or to a JSON string parameter, there are clear completeness gaps.

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 adds no per-parameter meaning and does not clarify how the nine optional parameters relate to the key-counting behavior; it relies entirely on the schema descriptions.

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

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

The description uses a specific verb and resource: 'Count keys in a JSON object.' It also adds a behavioral qualifier, 'Values discarded,' which distinguishes it from validation or transformation tools like validate-json. It is not perfectly clear whether the count refers to the top-level input object or to a JSON string passed through the `json` parameter, but the intent is mostly 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 usage is implied by the function: use this tool when you need to count keys in a JSON object and do not need the values. However, there is no explicit guidance about when not to use it or how it compares to sibling tools such as validate-json, domain-shape, or memory-related 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, the description carries the full burden and it does disclose an important behavior: query/fragment are dropped. However, it does not explain behavior on invalid URLs, how other input parameters are treated, or the exact definition of 'origin'.

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. Every clause adds information: the first states the output, the second states what is intentionally omitted.

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, yet the description only addresses one URL-related behavior. It does not tell an agent to disregard the other parameters, leaving ambiguity about whether fields like 'host' and 'path' are inputs or merely named outputs.

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 meaning beyond the schema; it neither clarifies that only 'url' is meaningful nor resolves potential confusion around the 'host' and 'path' inputs matching the output 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 states a concrete action ('Return origin, host, and path') on a clear resource ('a URL'), and further specifies what is removed ('Query and fragment are dropped'). This is specific enough to distinguish it from sibling tools that check, fetch, or validate URLs.

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 URL component extraction is needed, but it gives no explicit guidance about when not to use it or which sibling alternatives might apply. No exclusions or use-case boundaries 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, the description carries the full burden. It does disclose a meaningful non-obvious behavior ('Query text discarded') and suggests a read-style lookup via 'Find' and 'Returns'. However, it does not mention side effects, authentication needs, freshness, error behavior, or how the returned hops/setup are produced.

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 three short sentences with the purpose front-loaded, followed by return categories and one caution. There is no filler or repetition, and each sentence earns its place.

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

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

For a tool with 9 optional parameters, no annotations, and no output schema, the description is not complete enough. It explains what is returned but not how to select or combine parameters, what 'remote MCP hops' means, or when this should be preferred over similar sibling tools. An agent would need to guess or probe to understand the intended call pattern.

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

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

Schema coverage is 100%, and all parameters have descriptions, so the baseline is 3. The description adds little beyond the schema; 'Query text discarded' essentially restates the query parameter's schema description. It does not explain how parameters affect the returned CLI setup, docs, API, or hops.

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 opens with 'Find a living people-search index (Ploid)', which is a specific verb and resource, and lists the kinds of outputs returned. It is not a tautology and is clearly distinct from most sibling tools by subject area, though it does not explicitly differentiate itself from similar index tools like agent-tool-index.

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. It does not name sibling tools or describe conditions that should route an agent here instead of another tool. 'Query text discarded' is a caveat, not a usage guideline.

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

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

The description discloses a meaningful behavioral trait: 'No browser is launched.' With no annotations available, the description carries the full burden, yet it does not explain what 'can be opened' means, whether network requests are made, return values, or side effects, leaving important ambiguity.

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

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

The description is a single, front-loaded sentence with no redundant words. The core purpose and a key qualifier are presented efficiently, making it easy to parse quickly.

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

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

For a tool with no annotations, no output schema, and a seven-parameter schema, the description is too sparse. It omits the required parameter, return behavior, and the role of the non-URL parameters, so an agent has insufficient information 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 descriptions are present but only partially informative (50% coverage), and the tool description adds no parameter-level meaning. It does not clarify that 'url' is the primary parameter or that the other fields like 'ref', 'city', and 'feed' are discarded, making it hard for an agent to know which arguments are relevant.

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 URL can be opened.' The added note 'No browser is launched' provides a clarifying qualifier that hints at how it differs from a browser-based sibling. However, it does not explicitly name alternatives or reconcile with the unusually broad parameter set.

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

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

No explicit when-to-use or alternative guidance is provided. The 'No browser is launched' note implies a lightweight check compared to browser-based tools, giving an indirect usage context, but the description never names sibling tools or states exclusion conditions.

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

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

With no annotations, the description carries the behavioral disclosure burden. 'Query discarded' is a useful privacy-relevant detail, and 'Count characters' implies a non-destructive operation. However, the description does not specify the return format, behavior with no or multiple parameters, or any permissions or rate limits; the many 'discarded' notes appear only in the schema.

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

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

The description is two short, front-loaded sentences with no filler. Both sentences earn their place: one states the action and the other discloses the disposal behavior. It is appropriately sized for the simple operation described.

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 no annotations, no output schema, and several optional parameters, the description is thin. It omits the return shape, does not explicitly state that `query` is the relevant parameter, and does not describe behavior when other parameters or none are passed. The schema mitigates this, but the description alone does not fully equip an agent to call the tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description adds no parameter-level detail. Each schema parameter already describes its purpose and disposal behavior. The description does not clarify which parameter is 'the search query,' but the `query` schema entry aligns well enough.

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 operation: 'Count characters in a search query.' This is a specific verb and resource, and the tool name reinforces the purpose. It does not, however, explicitly name the `query` parameter or state the return type, and it does not contrast with sibling counting/check tools.

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

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

The description gives no guidance on when to use this tool versus alternatives, and no conditions or exclusions. With a schema containing many optional parameters, it also does not clarify that `query` is the intended argument or that unrelated parameters should be omitted. Usage must be inferred from the tool name and schema rather than from the description.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, yet it only says 'Short catalog' without stating whether the tool makes network requests, has side effects, or simply returns static data. The informational nature is implied but not explicit.

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

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

The description is a single short sentence with no redundant wording, making it very concise and front-loaded. It could be improved by including a verb and a brief usage hint, but it has no fluff.

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

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

For a tool with 9 parameters, no annotations, no output schema, and a description that does not tie the parameters to the tool's purpose, this definition is severely incomplete. An agent cannot determine what inputs to provide, what the tool returns, or how it behaves.

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 tool description adds no parameter-specific meaning. The individual parameter descriptions are clear, but none are connected to the stated purpose of an HTTP status catalog, and the description does not explain which parameters should be used or how they affect the result.

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 resource as a catalog of common HTTP status codes, which distinguishes it from sibling tools like fetch-status that check live statuses. However, it uses the noun 'catalog' rather than a specific verb like 'Lists' or 'Returns', so the action is slightly implicit.

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

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

No guidance is given about when to use this tool versus siblings such as fetch-status, web-fetch, or browser-url-ok. The description does not mention any condition, alternative, or prerequisite, leaving the agent to infer usage from the name alone.

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

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 add one meaningful behavior ('Prompt discarded') and implies a fixed, non-processing output, but it does not disclose that all schema inputs are effectively discarded or whether any side effects exist. Some transparency is present, but it is incomplete.

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

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

The description is extremely concise: two short sentences, front-loading the main output and adding a key behavioral caveat. There is no filler or redundancy.

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

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

The tool has no annotations and no output schema, so the description must provide more context. It fails to explain the role of the seven input parameters, what the three-step template looks like, or how this tool relates to the sibling validation tools. The mismatch between 'Prompt discarded' and a schema with no prompt field further undermines completeness.

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

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

The input schema gives descriptions for every parameter, so baseline is 3. However, those descriptions mostly say values are 'discarded' or 'checked', and the tool description adds no linking concept to explain why a three-step thinking template needs ref, url, city, feed, host, json, or path.

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 output ('Return a three-step thinking template') and a behavioral fact ('Prompt discarded'), but it does not explain what the template is for or how it relates to the many input fields. Without that context, an agent cannot tell exactly what task this tool accomplishes among the sibling validation and hint tools.

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

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

No when-to-use guidance is provided, and no alternatives or exclusions are mentioned. 'Prompt discarded' warns about behavior but does not help an agent decide when to invoke this tool instead of a sibling like domain-shape or validate-json.

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 full behavioral disclosure. It states the primary read-only behavior ('Current time in a named IANA timezone') and implies no side effects, but it does not specify output format or invalid-timezone handling. Adequate but thin.

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 short, front-loaded sentence with no fluff. For such a simple tool, this is an appropriately concise 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?

Despite the simple core behavior, the tool has nine optional parameters, no output schema, and close sibling tools. The description does not say which parameter to use, what the response looks like, or how this differs from utc-time/iana-zones. A single sentence is insufficient for confident invocation.

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

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

The schema description coverage is 100%, so every parameter is already documented. The tool description adds only the notion that the timezone argument should be an IANA name, which the schema already states. It does not help disenangle the eight unrelated-sounding 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 identifies the tool's core function: returning the current time for a specified IANA timezone. It lacks an explicit verb but is still recognizable. It does not directly differenatiate from siblings like utc-time or iana-zones, but the 'named IANA timezone' wording helps disamguit.

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 utc-time or iana-zones, nor which of the nine optional parameters to populate. The correct usage must be inferred from the schema and sibling names, which is not ideal.

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 full responsibility for behavioral disclosure. It only states the output and does not reveal that the nine optional parameters are effectively discarded or ignored, nor does it clarify that the tool is side-effect-free. Given the unusual parameter list, this is a meaningful 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 a single, compact phrase with no filler or redundant wording. It is appropriately short for a simple utility tool, though the noun-phrase structure makes it slightly less polished than a full sentence would be.

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 does not specify the timestamp format (e.g., Unix epoch, ISO 8601) or clarify that all inputs are optional and ignored. An agent cannot be fully certain what value to expect when invoking the tool.

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

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

Schema description coverage is 100%, with each parameter having an explanatory description such as "discarded after the shape check" and "no disk access." The main description adds no parameter-level meaning, so the baseline score of 3 applies because the schema already handles parameter documentation.

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?

"Current UTC timestamp" clearly states that the tool returns the current UTC time, and the mention of UTC helps distinguish it from sibling timezone-related tools like `timezone` and `iana-zones`. However, it is a noun phrase rather than an explicit verb+resource statement, so it lacks a small amount of directness.

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 the agent needs the current UTC timestamp, but it provides no explicit guidance about when not to use it or how it compares to alternatives. There are no exclusions, prerequisites, or references to sibling tools.

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

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

The description discloses one behavioral trait: 'The body is discarded.' However, no annotations are provided, so the description carries the full burden. It does not mention the return value, error behavior, side effects, or how the other parameters are processed. This is minimal disclosure for a validation 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 description is a single sentence with no wasted words. It states the core purpose and a meaningful behavioral note. While it is sparse, conciseness itself is served well; there is no fluff or repetition.

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 seven parameters, no annotations, and no output schema. The description explains only one aspect (the body is discarded) and ignores the other parameters, their interrelationships, and the outcome of the check. An agent cannot fully understand the tool's behavior or how to invoke it correctly from this 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 descriptions already cover all seven parameters, including the 'json' field described as 'JSON text to validate; discarded after the check.' The description's 'body is discarded' merely echoes the schema's per-parameter discards without adding new meaning. With high schema coverage, the baseline of 3 is appropriate.

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

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

The description clearly states the verb and resource: 'Check whether a body is valid JSON.' This makes the primary purpose unambiguous. However, it does not explicitly differentiate from sibling tools that also perform validation or shape checks (e.g., domain-shape, compatibility), though the tool name itself is fairly distinctive.

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 neither states a preferred context nor mentions exclusions or alternative tools. The sibling list contains many validation-like tools, but the description provides no 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 carries the full burden of behavioral disclosure, and it only states the data source and output concept. It does not mention that most input parameters are discarded, that city is the operative parameter, or any error, units, or rate behavior, leaving the agent to guess call semantics.

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 or repetition and front-loads the core purpose. It is concise, though the brevity contributes to the lack of 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?

For a tool with nine optional parameters and no output schema or annotations, this one-line description is not enough. It does not explain what the response looks like, how to use the city parameter, why the other parameters exist, or what happens on invalid input, so an agent cannot fully judge 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 schema already documents all nine optional parameters. The description adds only that city is the weather target and names Open-Meteo, which is useful but does not go beyond the schema's per-parameter descriptions.

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

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

The description names a concrete resource (city temperature) and the external service (Open-Meteo), which makes the tool's goal recognizable and distinguishes it from sibling tools like geo-hint. It lacks a leading verb such as '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?

The phrase 'current temperature for a city' implies the tool is for weather lookups, so an agent can infer when to try it. However, there is no explicit guidance about when to prefer it over geo-hint or other sibling tools, and no statement of exclusions or prerequisites.

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

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

With no annotations, the description carries the transparency burden. It discloses the important behavioral trait that the body is discarded, but it does not mention redirect handling, error behavior, response shape beyond status/content type, or how the many non-URL schema parameters relate to the 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 two short sentences with no filler. The first states the operation and output, and the second adds a critical limitation. 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 definition is incomplete for reliable invocation given 9 optional parameters, no output schema, and no annotations. It does not explain what parameters like ref, city, feed, host, json, path, timezone, and query do in this tool, whether url is effectively required, or what the response structure contains beyond status and content type.

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 documents each parameter and its discard behavior. The tool description itself adds no per-parameter detail, and it does not resolve the mismatch between the URL-focused description and the eight other 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 that the tool returns HTTP status and content type for a public URL, and explicitly notes that the body is discarded. This is specific about the core operation, though it does not distinguish itself from sibling URL/status tools by name.

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

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

'For a public URL' and 'Body discarded' imply the tool should be used when only reachability and content type are needed, not page content. However, there is no explicit guidance about when to prefer a sibling tool like fetch-status or browser-url-ok.

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. 'Title discarded after the call' does add a side-effect-free hint beyond the name, but it does not disclose the return type, failure behavior, network dependence, or what happens when the title does not exist. The disclosure is minimal.

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

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

The description is brief and front-loaded with the action verb. There is no filler or redundant phrasing. The second sentence about discarding the title is compact and adds a behavioral note, though it would be less confusing if paired with a matching 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?

With no output schema and no annotations, the description must carry the full invocation contract, and it does not. The agent is left without knowing which parameter contains the title, what the tool returns, or how to handle errors. For a tool with seven loosely described parameters, this is severely 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?

All schema properties have descriptions, so the baseline is 3, but those descriptions are wholly unrelated to checking a Wikipedia title and consistently mention 'discarded after'. The main description never connects the word 'title' to any of the seven parameters, leaving the agent unable to determine which field 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 states a clear predicate: 'Check whether a Wikipedia title exists.' However, the input schema contains seven unrelated parameters (ref, url, city, feed, host, json, path) and no 'title' parameter, so an agent cannot map the stated purpose to any concrete input. It is not a tautology, but the purpose becomes ambiguous once the schema is considered.

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

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

The description offers no guidance about when to choose this tool over alternatives, when not to use it, or what prerequisites exist. Given many sibling validation tools like browser-url-ok, file-path-ok, and domain-shape, the absence of routing or exclusion guidance is a meaningful gap.

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