XML well-formed check, body discarded

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 usefully states that task text is discarded and that the tool returns connection methods, implying a read-only, privacy-conscious lookup. It does not, however, disclose cost implications, network side effects, or the structure of returned connection methods.

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 with the core purpose, and every sentence earns its place: what it finds, what it returns, and what is discarded. No filler or redundant text.

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

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

Even though the schema handles parameters well, the tool has 9 optional inputs, no annotations, no output schema, and no explanation of how the params relate to the task categories. An agent cannot fully infer what inputs are needed to obtain a gateway or what 'connection methods' will look 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 baseline is 3; the property descriptions already explain each param. The tool description does not add meaningful relational meaning beyond that, such as which combinations of params are relevant for which tool categories.

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

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

The description states the specific action: find a public pay-per-call tool gateway for task categories like weather, search, scrape, or voice, and return connection methods. It is clear enough to distinguish this tool from the sibling validator/hint tools, though the core term 'tool gateway' is somewhat jargon-heavy.

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 task categories 'weather, search, scrape, or voice' provide clear usage context, and the phrase 'Task text discarded' signals how it should be called. It omits explicit alternatives or when-not-to-use guidance, so it misses the top tier.

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

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

With no annotations provided, the description carries the burden of disclosing behavior. It does state that no browser is launched, which is useful, but it omits other crucial behavior: whether network access occurs, what 'ok' means, what the return value looks like, and whether input is normalized or merely validated.

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

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

The description is brief and front-loaded, with no filler or repetition. The two sentences each carry information: the primary purpose and a key behavioral clarification. However, it is somewhat too sparse given the tool's complexity and sibling context, so it does not reach a 5.

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

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

Given the large sibling family and 9 optional parameters, the description needs to explain more about when to use this tool and what 'can be opened' means. It lacks any detail about return behavior, input relevance, or relationship to similar tools, so the tool definition is incomplete enough that an agent could easily misuse it.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters. The tool description itself adds no additional parameter semantics, but per the baseline rule, when schema coverage is high, the description need not repeat schema details. A 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 ('Check whether a URL can be opened') and adds a meaningful constraint ('No browser is launched'), which distinguishes it from browser-launching siblings like playwright-url-ok. It does not explicitly name sibling tools or the exact meaning of 'can be opened', but the core purpose is clear.

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

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

The description gives no guidance on when to use this tool instead of alternatives such as normalize-url, fetch-status, or playwright-url-ok. It provides no exclusions, no prerequisites, and no context about URL types or expected inputs, so an agent would struggle to select it confidently.

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

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

No annotations are present, so the description alone must carry behavioral transparency. It discloses that the expression is discarded, but it does not state what the tool actually returns, whether it has side effects, or whether the arithmetic result is accessible. The statement 'Evaluate ... Expression discarded' is internally contradictory and under-discloses the tool's real behavior.

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

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

The description is extremely short, but conciseness should not undermine clarity. 'Expression discarded' is cryptic and cheats the reader of enough context; it does not earn its place. The structure front-loads a claim that the schema contradicts, so it is not a 'clear + efficient' example of conciseness.

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

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

With 9 optional parameters, no output schema, no annotations, and no behavior detail, the description is far from complete. A tool expecting arithmetic evaluation should at the very least tell the agent which parameter or how to pass the arithmetic expression. Without that, the description is insufficient for safe/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 by the rubric the baseline is 3. The description adds no meaning to parameters; it does not map any param to the 'expression' mentioned in the description, making it unclear which of the 9 optional parameters should be supplied for arithmetic evaluation. The description fails to link the action to any parameter and is effectively no information 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 names a specific action ('Evaluate a+b style arithmetic') and thus is not a tautology. However, the phrase 'Expression discarded' is ambiguous and no schema parameter corresponds to an expression, so an agent cannot tell what to pass. It does not meaningfully distinguish from siblings because there are no similar arithmetic-related tools listed.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no explanation of what inputs are needed or what triggers success/failure. The description leaves the agent to guess how the 'expression' relates to the parameters (e.g., url, query) and whether this tool is even for arithmetic in practice.

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 behavioral burden, but it only says page content is not stored. It does not state whether it makes a network request, what it does with the URL, whether it requires network access, or what the output shape 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 compact and front-loaded, stating the core output first and adding a relevant privacy note in the second sentence. There is no filler or redundant restatement.

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

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

Given no annotations, no output schema, and nine optional parameters, the description is too thin to support correct invocation. It leaves unclear which parameters to supply, what the output structure is, and why the other parameters are relevant or discarded.

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

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

The input schema has 100% description coverage, so the baseline is 3. The description adds no parameter-level meaning beyond mentioning 'URL', and it does not explain how the nine optional parameters relate to the stated behavior.

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

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

The description clearly states the action is to return host, scheme, and HTTP status for a URL, so an agent knows what the tool generally does. It does not differentiate it from close siblings like fetch-status or normalize-url, both of which could plausibly return similar information.

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

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

No guidance is given about when to choose this tool over siblings such as normalize-url, fetch-status, or browser-url-ok. The description does not mention exclusions, prerequisites, or common calling patterns.

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

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

Annotations are absent, so the description carries the full burden of behavioral disclosure. The statement 'No identifiers are retained' is a useful privacy guarantee, but the description does not say whether the tool is read-only, what it returns, or what side effects it may have.

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 definition is a single, non-redundant sentence and is front-loaded, but it is more under-specified than appropriately concise. It omits essential context, so its brevity does not serve the agent's need for information.

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

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

This tool has 9 parameters, no output schema, no annotations, and no meaningful description of what 'classification' means. An agent cannot determine what the tool does, what result to expect, or how to interpret the classification.

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

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

The schema provides complete descriptions for all 9 parameters (ref, url, city, feed, host, json, path, zone, query), so the schema already explains each parameter. The description adds no per-parameter semantics beyond the blanket privacy statement.

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

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

The description uses a verb ('show') and an object ('classification'), but 'request' and 'classified' are under-specified, leaving the tool's purpose ambiguous. It does not distinguish itself from the many sibling tools that also operate on URLs, JSON, paths, or timezones.

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, and there is no mention of how this tool relates to any of the 28 sibling tools. The description gives an agent no basis for choosing 'compatibility' over alternatives 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?

With no annotations at all, the description must carry the behavioral disclosure burden. It states a transformation but does not reveal side effects, read-only guarantees, rate limits, return shape, or whether it performs any external lookup. 'Without WHOIS or ownership data' only narrows the expected output; it does not describe actual runtime 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 efficient sentence with no filler and is appropriately front-loaded. While it could be more informative, it is definitely concise rather than over-padded.

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, one sentence about splitting hostnames is drastically incomplete. It does not mention return values, which parameter should be supplied, or what happens to the unused fields, so an agent cannot confidently invoke 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 structured schema already explains all parameters, leaving the description with little extra to add. The mention of 'hostname' loosely implies the host parameter, but the description does not add semantic value for the other eight fields or explain how they interact.

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

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

The description names a concrete action and resource: 'Split a hostname into labels'. However, the input schema lists nine unrelated optional parameters, and the description does not explain why those exist or which one the action applies to, leaving the true scope unclear. It also does not differentiate this tool from sibling shape-checking tools.

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

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

No guidance is given about when to use this tool instead of a sibling such as normalize-url, github-repo-shape, or geo-hint. The phrase 'without WHOIS or ownership data' hints at what the tool does not do, but does not say when it is preferable or what prerequisite the caller should satisfy.

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. It reveals the HTTP method and that only status is returned, but it stays silent on how the other eight accepted params are handled (the schema says they are 'discarded after the shape check'), what a non-URL input returns, and what failure modes or limits apply.

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 front-loaded and waste-free, but for a nine-parameter tool with multiple apparent input modes it is severely under-specified rather than concise. Under-specification is not conciseness.

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

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

With no annotations, no output schema, and nine optional parameters spanning many domains, one line is insufficient. An agent cannot determine the full input space, what output shape 'status only' takes for non-URL inputs, or how this tool complements its siblings.

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 the schema descriptions themselves add semantic value (e.g., 'discarded after the shape check', 'no disk access'), so the description is not required to document parameters further. Per the baseline rule for high coverage, a 3 is appropriate; the description neither harms nor meaningfully adds parameter understanding.

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 and resource ('HEAD a public URL') and states the return ('status only'), so the URL mode is identifiable. However, the schema exposes nine unrelated parameter modes (path, zone, json, query, city, feed, host, ref), which suggests the tool is actually a multi-input shape-status checker, and several siblings (browser-url-ok, playwright-url-ok, web-fetch) overlap the URL-status space without 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 when-to-use guidance, no mentioned alternatives, and no exclusions. With siblings like browser-url-ok, playwright-url-ok, normalize-url, web-fetch, and status-catalog available, an agent has no textual basis for selecting this tool over them.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The only behavior disclosed is that the path is discarded; it does not mention whether the tool performs network access, validates the URL, or what happens with the other eight parameters. This is a significant gap for a tool with no annotation fallback.

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

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

The description is extremely brief and front-loaded, with no filler. It earns its place, though the trade-off is that critical contextual information is missing; this is effective conciseness but not comprehensive.

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 complexity of a 9-parameter schema, no output schema, and no annotations, the description is underdeveloped. It does not explain the tool's behavior comprehensively, does not state return values, and leaves the agent to make sense of why unrelated inputs are accepted. For a tools with nine parameters, this is not enough to be confidently used effectively.

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

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

Schema coverage is 100%, so each of the 9 parameters has a description. The tool description's 'Path discarded' note adds slight value beyond the schema by hinting at URL path handling, but it does not explain the relationship between the Figma URL intent and the many unrelated parameters, nor does it clarify which parameters are relevant for a typical call.

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+resource, 'Parse a Figma file URL,' which clearly distinguishes it from generic URL tools like normalize-url. The note 'Path discarded' adds a small behavioral hint, but it does not state what the parse returns or what constitutes a valid Figma URL shape, so it is not a 5.

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

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

The description implies usage when a Figma file URL needs parsing, but it does not explicitly contrast with sibling tools such as normalize-url, web-fetch, or file-path-ok. No exclusions or 'when-not' guidance is given, leaving the agent to infer selection 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?

The 'No disk access' sentence is a useful behavioral disclosure, especially given no annotations are provided; it sets the expectation that this tool will not touch the filesystem. But the description does not disclose return format, what 'safe' means in practice, or how failures are reported. The single safety constraint is a good start but not comprehensive.

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

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

The description is a two-sentence fragment with zero filler: 'Check whether a path looks safe. No disk access.' The purpose is front-loaded and every word carries information. This is appropriately concise, though it is close to under-specification in other dimensions.

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 and no output schema or annotations, the description is thin. The schema documents parameter semantics, but the description fails to tie the checker's purpose to the full set of inputs, and gives no guidance on how results are encoded. It is workable but leaves a real gap between the stated purpose and the actual input surface.

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

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

Schema description coverage is 100%, so parameters are already well documented in the schema, but the description adds nothing about them. It never mentions 'ref', 'url', 'city', etc., nor does it explain why so many unrelated parameters exist. The description adds no meaning beyond the schema, so a baseline 3 is appropriate.

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

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

The description states a specific action ('Check whether a path looks safe') and a resource ('a path'), which clearly distinguishes it from URL-focused siblings like browser-url-ok or normalize-url. 'looks safe' conveys it is a shape/format check rather than a real file operation. However, it does not explain what the result looks like, which is a moderate gap.

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 about when to use this tool versus alternatives. It does not mention that path safety checks should be done before file access operations, nor does it advise using a URL-checking sibling for URLs. An agent has to infer usage from the name and sibling list.

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 explaining behavior. It only says data comes from external service Open-Meteo; it does not disclose input requirements, unknown city behavior, network dependency, side effects, 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 direct, front-loaded, and contains no filler. The single sentence does present the core purpose clearly, but it is terse in a way that leaves application guidance to other dimensions.

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

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

This tool has nine optional parameters, no annotations, no output schema, and no usage or failure details. The one-sentence description is not enough for an agent to know exactly which input to use, how to interpret the output, or what happens in invalid cases.

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 at 100%, so each parameter is already documented in structured form. The description adds no parameter-specific meaning beyond 'place,' and it leaves the reader to infer that city is the likely relevant parameter.

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

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

The description states that the tool returns latitude and longitude for a place using Open-Meteo, which names both the output and the data source. However, it does not identify which of the nine schema fields supplies the place, and it does not explicitly distinguish itself from sibling tools like weather-hint.

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

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

The description gives no guidance on when to use this tool versus weather-hint, timezone, iana-zones, or other siblings. There are no stated exclusions, alternatives, or conditions that would help an agent decide when this tool is the right choice.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only says 'parse' and does not reveal whether the tool makes remote calls, how invalid or non-GitHub URLs are handled, or what happens to the extra schema parameters. This leaves the operational behavior ambiguous.

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, dense sentence with no filler; it clearly identifies the verb, resource, and scope. Every word contributes to the meaning.

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

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

There is no output schema, and the description does not explain the return shape or behavior on invalid URLs. With nine parameters, many of which appear unrelated, and no annotations, an agent lacks a complete contract for how to invoke 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 coverage is 100%, with per-parameter descriptions for all nine fields. The tool description adds the GitHub URL context and the owner/repo result, but it does not clarify which parameters actually participate in the operation or how the other eight are ignored. The baseline of 3 is appropriate because the schema already describes each parameter.

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

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

The description states a specific verb ('Parse'), a specific resource ('owner and repo'), and a specific input ('GitHub URL'), which allows an agent to distinguish it from sibling shape tools such as figma-url-shape or jira-key-shape. The purpose is unambiguous and immediately actionable.

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 when-to-use guidance and no mention of when to use an alternative tool for non-GitHub URLs. From the description alone, an agent cannot infer how this tool relates to options like normalize-url, domain-shape, or jira-key-shape.

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 most behavioral disclosure. It does state a key behavior: the tool counts current stories and discards titles. It does not mention whether this performs a network fetch, whether any input parameters are used, or what the exact response shape is, leaving some behavioral 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 compact and front-loaded: the main action and resource appear first, and 'Titles discarded' adds a meaningful constraint in a short second sentence. There is no filler or redundant phrasing.

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

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

For a simple count tool, the description gives enough intent to call it with no required arguments and expect a count. But with no output schema, no annotations, and nine optional parameters, an agent is left uncertain about whether parameters are ever used and what the exact response format will be. Some contextual gaps remain.

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

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

Schema description coverage is 100%, and all nine parameters are optional, so the baseline is 3. The tool description itself adds no parameter-level meaning and does not clarify why the schema contains unrelated-looking generic parameters such as city, zone, or ref. The schema descriptions themselves carry the parameter 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 uses a specific verb ('Count'), a concrete resource ('current Hacker News front-page stories'), and adds a useful boundary with 'Titles discarded.' It is clear and distinguishable from the broader fetch/check tools, though it does not explicitly differentiate itself from sibling tools in the same domain.

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 case is implied: use this when you need a count of current HN front-page stories. The phrase 'Titles discarded' also implies you should not use it when you need headlines or titles. However, there is no explicit when-to-use or when-not-to-use guidance and no named 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 exist, so the description carries the full burden of behavioral disclosure. It only says 'common IANA timezone names', without stating whether this is a read-only lookup, what it returns, or what occurs when the tool is called. It does not contradict the schema, but it leaves the actual behavior largely unstated.

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 short, front-loaded phrase with no fluff; the key terms 'IANA' and 'clock calls' appear immediately. It is terse almost to the point of under-specification, but it is still concise and easy to parse.

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

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

Given the tool's likely simple output (a list of common IANA zone names) and the fully documented input schema, the one-line description is a functional minimum. But with nine parameters and no output schema or annotations, the description is not sufficiently complete by itself; it does not explain what inputs are relevant or what results are 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%, and the `zone` property is reasonably aligned with the IANA-timezone purpose, so the baseline can hold. However, the description itself adds little to meaning: it does not explain the purpose of the many non-zone parameters, nor does it clarify how they relate to the stated tool goal.

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: common IANA timezone names, and ties it to clock/clock-call usage. It does not use an explicit verb such as 'list' or 'returns', and it does not explicitly distinguish itself from siblings like `timezone` or `utc-time`, so it is clear but not maximally self-differentiating.

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 light usage context: the tool is useful when a common IANA timezone name is needed in that area. It does not provide explicit when-to-use/when-not-to-use guidance, nor does it name sibling alternatives like `timezone` or `utc-time`, so an agent must infer the selection rule.

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 discloses only that the fetch is 'public' and that only group counts are returned; it says nothing about handling missing or 404 robots.txt files, rate limits, network failures, or what 'group counts' means (user-agent groups?). The behavioral disclosure is too thin for a network tool with no annotation safety net.

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 zero wasted words: verb, resource, and output are packed in tightly. It could afford slightly more detail given the complexity, but as one sentence it is appropriately terse and organized.

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 output schema, and no annotations, a one-sentence description is inadequate. It does not say which parameters are relevant to the robots.txt fetch, does not define the response shape or the semantics of 'group counts', and the mismatched schema descriptions would leave an agent guessing about correct invocation. An agent would need to probe or make assumptions before calling successfully.

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%, which raises the baseline to 3, but the parameter descriptions appear pasted from unrelated tools and are misleading for this purpose: 'url' is described as 'HTTPS URL to normalize or cite', and ref/city/feed/json/path/zone/query are clearly off-topic for counting robots.txt groups. Worse, no parameter description says it is the robots.txt location, so an agent cannot tell whether 'url' or 'host' is the intended entry point. The mismatch drops the score below the baseline.

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

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

The description names a specific verb ('Fetch'), a specific resource ('a public robots.txt'), and a specific output ('return group counts only'). This is clear and distinguishable from siblings like web-fetch or fetch-status in spirit, though it never names an alternative explicitly, so it stops short of a 5.

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

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

There is no guidance about when to use this tool versus web-fetch, normalize-url, fetch-status, or other siblings. The single sentence provides no prerequisites, exclusions, or conditions that would help an agent choose among the many URL/fetch-related tools in the sibling list.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says the key is discarded; it says nothing about whether this is read-only, what it returns, whether it needs network access, or what happens on an invalid shape.

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

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

The description is short and front-loaded with its core purpose, with no filler. It loses a point because the brevity contributes to under-specification rather than pure clarity.

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

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

For a tool with 9 parameters, no annotations, and no output schema, this description is incomplete. It does not say how the parameters relate to the Jira key check, what a valid result looks like, or what the tool returns.

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. However, the description does not identify which parameter carries the Jira issue key, and the 9 input properties are described as unrelated strings (URL, city, feed, JSON, path, etc.), leaving real invocation ambiguity.

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

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

The description states a specific verb, 'Check', and a specific resource, 'a Jira issue key', which distinguishes it from sibling shape tools like github-repo-shape or domain-shape. It is not a 5 because 'shape' is not defined and the relationship between the description and the 9 input properties is unclear.

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

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

There is no usage guidance about when to use this tool versus the many sibling shape/check tools. No conditions, prerequisites, or when-not-to-use examples 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?

There are no annotations, so the description carries the behavioral burden. 'HTTP status' and 'body discarded' are meaningful behavioral signals, but redirects, error behavior, rate limits, and any side effects are not disclosed, keeping this below a 4.

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 succinct and front-loaded, with no filler. It could add more behavioral and usage detail without becoming wordy, but it is not bloated.

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

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

With 9 optional parameters, no annotations, no output schema, and many sibling tools, this description is too thin. It does not explain how to invoke the tool, which property carries the real URL, what the output format is, or what makes it distinct from similar status-fetching 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 every parameter already has its own description and the baseline is 3. The tool description adds little parameter-level meaning and does not clarify which optional properties should be supplied, especially given the overloaded 9-property 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 names a concrete outcome: an HTTP status for a URL, with the body discarded. It is clear enough to identify the tool as a status-only check, but it does not explicitly contrast itself with sibling tools such as 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 description implies the input is a public library docs URL, but gives no when-to-use guidance, no exclusions, and no mention of alternatives. An agent cannot tell when to choose this tool rather than the many URL/HTTP siblings.

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

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

With no annotations present, the description carries the full behavioral burden, but it only discloses that values are discarded. It does not say whether the tool has side effects, whether it needs any permissions, or how it handles invalid input. The concise note adds a small insight, but important behavior remains undocumented.

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

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

The description is extremely concise, using two short sentences with no fluff. Each sentence contributes useful information (purpose and a behavioral detail) without redundancy. The structure is front-loaded and easy to skim.

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 its simple goal, the tool has 9 parameters, no output schema, and no annotations. The description is far too terse to explain which parameter is the JSON object, what the return value looks like, or how to distinguish it from validate-json. Given the complexity, this is an incomplete specification.

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

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

The schema descriptions cover all 9 parameters, which raises the baseline to 3 because parameters are already individually documented. The description does not add extra clarity about which parameter to use, e.g., pointing to the JSON string field. Given the confusion caused by eight unrelated parameters listed, a 3 is fair but not generous.

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 ('Count keys') on a specific resource ('JSON object'), so the tool's basic function is clear. It does not explicitly differentiate it from sibling tools like validate-json, but the semantic difference is evident enough on its own. The odd mismatch with the large parameter schema however leaves ambiguity about what input is consumed.

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, when not to, or how it relates to validators/other count tools. No alternative tools are mentioned, and there is no practical usage context such as prerequisites or intended scenarios. The reader is left to infer the use-case 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It clearly reveals that query strings and fragments are intentionally dropped and that the result is composed of origin, host, and path. It leaves error behavior unspecified, but the core behavioral contract is well stated.

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 deliver the purpose and the key behavioral caveat with no filler. The main claim is front-loaded, and every clause adds information an agent would need before calling the tool.

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

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

The description is adequate for a simple URL parser, but with 9 optional parameters and no output schema, it could do more to clarify which parameter is the primary input and how the other parameters relate to the task. The schema supplies most parameter semantics, but the tool-level guidance is thin.

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 all 9 parameters. The tool description does not add much parameter-level meaning beyond the schema; it only tells what the overall output is. That matches the baseline for full schema coverage.

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

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

The description clearly identifies the action ('Return origin, host, and path') and the resource ('a URL'), and it adds the useful scoping detail that query and fragment are dropped. It does not explicitly contrast itself with URL-related sibling tools like browser-url-ok or playwright-url-ok, so it does not fully earn a 5.

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

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

There is no guidance about when to choose this tool over sibling URL/host tools, nor is there a statement of when not to use it. The description states what it returns, but it does not help an agent decide which tool is appropriate for a given task.

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

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

With no annotations, the description carries the full behavioral burden yet discloses only 'no browser is launched'. It omits whether a network request occurs, whether there are timeouts, redirect behavior, success criteria, or side effects. This is inadequate for an agent that must call the tool without prior knowledge.

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 tight: two short sentences, purpose first, followed by the key behavioral caveat. Every word earns its place, though the brevity leaves critical semantic gaps.

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 required parameters, no output schema, and no annotations, this description is not enough. It fails to explain what 'ok' means, which parameter the caller should supply, or what the return value conveys, leaving the agent to improvise on a multi-parameter tool.

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

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

Schema description coverage is 100%, so the baseline is 3 even without the description adding parameter details. The description itself adds no parameter meaning and does not reconcile why unrelated params like timezone, city, and JSON coexist with a URL-checking tool, nor which param is the primary input for 'opened'.

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: 'Check whether a URL can be opened', and adds a distinguishing qualifier 'No browser is launched' that separates it from browser-based siblings. However, 'opened' is ambiguous (reachable? renderable? acceptable status?) and it never names sibling tools, so full differentiation is left to inference.

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 statement about when to use this tool vs. alternatives like browser-url-ok, web-fetch, fetch-status, or normalize-url. The 'No browser is launched' sentence hints at a lightweight check, 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?

With absolutely no annotations, the description carries the behavioral burden. It does add the meaningful disclosure 'Query discarded', telling the agent that the input is not persisted. However, it does not mention what the tool returns, whether it is idempotent/safe, or how it treats the other optional schema parameters, leaving gaps for a description with no annotations.

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

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

The description is two short sentences with zero filler. 'Count characters in a search query.' states purpose, and 'Query discarded.' adds a meaningful behavioral detail. Every sentence earns its place.

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

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

The tool is a simple operation, but the context is under-specified: there is no output schema, no annotations, no required parameters, and 9 optional input properties. The description does not explicitly tell the caller which property to pass ('query') nor what the call returns (likely a numeric character length). An agent selecting and invoking this tool correctly would need to infer a lot from the property name alone.

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

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

Schema description coverage is 100%, so the baseline is 3. The description paraphrases the 'query' parameter by talking about a 'search query' but does not add additional meaning, such as clarifying that 'query' is the sole input consumers should provide or that the other eight params are ignored. The schema already describes each property well.

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: 'Count characters in a search query.' It identifies both the action and the resource, making the tool's purpose immediately obvious. This also distinguishes it from sibling count/shape tools such as memory-key-count and domain-shape.

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

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

The description provides no indication of when to use this tool versus alternatives, nor does it mention why an agent should choose 'search-query-len' over a generic length or validation tool. Usage is only implied by the tool's name and the stated action.

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 behavioral burden, and it is nearly silent here. It never states whether the catalog is static or filtered, whether all input parameters are discarded (schema mentions 'discarded' only in parameter descriptions), what the output shape is, or whether there are side effects. The word 'catalog' hints at a read-only reference, but that is not explicit.

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

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

The description is a single short sentence with no filler, and it places the subject ('HTTP status codes') immediately. It is under-specified, but that deficiency is better attributed to other dimensions; structurally, it is clean, front-loaded, and easy to parse.

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

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

For a tool with 9 optional parameters, no output schema, no annotations, and 30 siblings, the description must clarify the return format, the role of the parameters, and when to choose this tool. It leaves all of these unresolved. Which catalog entries are returned and whether any parameter can filter them is left entirely to inference.

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

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

The schema covers all 9 parameters with descriptive text, so the baseline of 3 applies even though the tool description adds nothing about them. The description does not explain how a Git ref, city, timezone, or JSON text relates to the status-code catalog, so it fails to compensate for the obvious semantic mismatch.

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 a specific resource — a catalog of common HTTP status codes — and distinguishes it from tools that fetch or test URL statuses. However, it offers no explicit differentiation from siblings such as fetch-status or browser-url-ok, and the 9 unrelated parameters make the actual behavior harder to pin down.

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

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

The description gives no guidance on when to choose this tool over the 30 siblings, nor exclusions or alternatives. An agent has no information on whether to use it for lookups, teaching, or mappings, and cannot distinguish it from status-checking tools in the sibling list.

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 must carry the burden of explaining observable behavior. It discloses one thing: the prompt is discarded. But it does not state that the tool is read-only, whether it performs computation, or how it handles the schema parameters. For an unannotated tool with a vague side effect, this is insufficient.

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

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

The description is short and starts with the core action, which is structurally efficient. The second sentence, 'Prompt discarded.', is vague and arguably does not earn its place because it creates confusion about what prompt is being discarded rather than clarifying 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?

Given the absence of an output schema, annotations, and the presence of 9 unrelated optional parameters, the description is incomplete. It does not specify what the three-step template looks like, whether parameters are required, which are ignored, or what the agent should expect as a return value. This leaves too much room for mis-invocation.

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

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

The input schema already documents all 9 optional parameters at 100% coverage, so the description is not required to repeat them. However, the description itself adds no additional parameter insights, such as whether all parameters are ignored, which would be valuable. Baseline 3 is appropriate because the schema covers the parameter meanings.

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

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

The description states a verb and resource: 'Return a three-step thinking template.' That distinguishes the basic action, but it doesn't say what the template is for or how it relates to the 9 optional parameters. 'Prompt discarded' is cryptic and does not clarify the purpose relative to similar sibling tools.

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

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

No when-to-use or when-not-to-use guidance is provided. The description gives no hint about which sibling tools it substitutes, when an agent should select it, or what conditions require it. The phrase 'Prompt discarded.' implies the prompt is not used, but does not give actual selection guidance.

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

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

No annotations are provided, so the description must carry behavioral disclosure. It only states the core action and does not mention that most of the 9 schema properties are ignored or that only 'zone' is used. The schema itself documents the discarded parameters, but the description does not surface this behavioral quirk for an agent relying on it alone.

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?

A single, tight sentence with no wasted words. It is efficiently front-loaded and avoids redundancy or 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?

Despite being a logically simple tool, the presence of 8 apparently irrelevant parameters creates ambiguity. The description does not warn that those parameters are ignored, nor does it name the specific 'zone' parameter to use. Without that context, an agent could easily pass the wrong parameter or be confused by the schema noise.

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

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

Schema description coverage is 100% for all 9 parameters, so the schema already documents each property. The description adds slight value by identifying the relevant parameter as an IANA timezone, but it does not elaborate on the other parameters or clarify their lack of effect.

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: 'Current time in a named IANA timezone.' This clearly differentiates it from sibling tools like iana-zones (list zones) and utc-time (UTC time). An agent can identify its purpose without inspecting the schema.

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

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

No guidance on when to use this tool versus alternatives. It does not mention 'use for local time, use utc-time for UTC' or clarify that the zone parameter is the intended one. The usage context is entirely implicit.

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

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

No annotations are provided, so the description carries the full behavioral burden, but 'Current UTC timestamp.' only states the output. It doesn't disclose that all inputs are ignored, that the then tool has no side effects, or that it accesses the system clock; the schema's 'discarded after the check' notes do some of this work but belong to structured data. There is no contradiction, but also little added transparency.

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

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

One substantive clause with zero filler earns high marks for brevity, but this is under-specification rather than conciseness: a tool accepting 9 parameters and being effectively a no-op with respect to all of them should say it. A slightly longer sentence like 'Return the current UTC time; any parameters are ignored' would be markedly more useful.

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 9 optional parameters, the description is incomplete: it doesn't state that all arguments are discarded, and the timestamp's format is undefined. Schema descriptions rescue most parameters ('discarded after the call' etc.), but zone ('IANA timezone name') and host ('Public hostname') don't explicitly say they're irrelevant, leaving room for an agent to believe geography or host affects the result. A single clarifying sentence about parameter-ixing would raise it.

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

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

Schema description coverage is 100%, with each of the 9 parameters individually documented (e.g., 'Git ref name; discarded after the shape check', 'JSON text to validate; discarded after the check'), so the baseline of 3 applies even though the description adds no parameter information. The description neither enriches nor detracts from what the schema already supplies.

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

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

The description 'Current UTC timestamp.' states a specific resource (UTC timestamp) and the action of the tool clearly, and the word UTC distinguishes it from siblings like timezone and iana-zones. It does not explicitly address that the 9 declared parameters are all inert, and it doesn't mention output format, so it stops short of a fully distinct definition. Overall the core purpose is unambiguous.

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

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

There is no guidance on when to call this tool versus timezone or iana-zones, nor any signal that it should be invoked with zero arguments. With 9 optional parameters whose descriptions almost read like a list of other tools' jobs, an agent must rely entirely on the schema's 'discarded' notes to infer that the parameters don't matter. The tool is effectively parameterless but nothing in the description says that.

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

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

The description discloses that the body is discarded, which is a useful side-effect note. But with no annotations, the description fails to explain return behavior, side effects, permissions, or whether the validation is purely local. This falls short of the full transparency burden.

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, direct sentence with no wasted words. The behavioral note 'The body is discarded' is front-loaded and useful. Each 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?

Even with a fully documented schema, the tool has 9 optional parameters and no output schema or annotations. The description does not tell the agent which parameter is the 'body' to validate, what a successful validation returns, or how to interpret the many unrelated parameters. Given the tool's complexity, the description is under-specified.

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

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

The schema provides 100% parameter description coverage, including 'json' as JSON text to validate and disclaimers like 'discarded after the check'. The description itself adds no new parameter guidance, but does not need to because the schema already documents all parameters. Baseline 3 is appropriate.

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

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

The description clearly states the verb and resource: 'Check whether a body is valid JSON.' It distinguishes the tool as a JSON validator without confusion. However, it lacks an explicit sibling distinction and uses 'body' without mapping it to the schema's 'json' parameter.

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 xml-ok, browser-url-ok, or domain-shape. It does not mention exclusions, prerequisites, or which parameter should be supplied for the validation. The only implied context is the tool name itself.

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 some burden, and 'via Open-Meteo' at least signals an external read-only lookup. However, it does not disclose the relationship between the nine optional schema parameters and the actual weather behavior, nor mention side effects, output format, or that most inputs are ignored.

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, immediately legible sentence with no filler. The core purpose is front-loaded and the external source is named.

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

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

For a simple data-retrieval hint, the description states what the tool returns, but the 9 optional parameters and the lack of an output schema leave ambiguity about how to actually invoke the tool and interpret the result. The description does not explain that the city parameter is the relevant one or what the output shape/units will be.

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

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

Schema description coverage is 100% and every parameter has a description, so the baseline is 3. The description itself only adds meaning for the `city` parameter; it does not compensate for the confusing presence of unrelated parameters like ref, url, or json.

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

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

The description clearly names a specific verb-resource pair ('Current temperature for a city') and a specific data source (Open-Meteo). It is easily contrasted with sibling tools like geo-hint or timezone, so an agent can tell it apart without inspecting the schema.

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

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

The description provides no guidance about when to reach for this tool compared to alternatives, no exclusions, and no mention of preconditions. It is only a bare statement of purpose.

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 transparently states that the body is discarded and that the URL is public, which is useful. However, it does not mention redirects, rate limits, auth, or other fetch behaviors that would be relevant for a network 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?

Two concise, front-loaded sentences with no filler. 'HTTP status and content type for a public URL' immediately communicates the core behavior, and 'Body discarded' is a useful single-sentence disclosure.

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 semantic gap between the description and the 9-parameter schema is significant: the parameters include refs, cities, feeds, zones, and queries, while the description only describes HTTP status/content type fetching. The description does not explain how these parameters relate to the tool or how to invoke it correctly, which is essential given the parameter count and no output schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds the behavioral note about discarding the body, but it does not clarify the relationship between the 9 optional parameters or explain which parameter should be passed as the URL to fetch.

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

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

The description clearly identifies the resource (public URL) and the expected outputs (HTTP status and content type), and adds the important detail that the body is discarded. It is specific and understandable, though it does not explicitly contrast itself with near-neighbor tools like fetch-status.

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

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

Usage guidance is only implied: if you need HTTP status and content type for a public URL, this tool may be appropriate. 'Body discarded' hints when not to use it, but no alternative tools or exclusions are mentioned despite many related siblings.

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

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

With no annotations, the description carries the full burden, but it only discloses that the title is discarded after the call. It does not state whether the title is read-only, what the call returns, whether it makes a network request, or any side effects. This leaves the agent with very little behavioral grounding.

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 and contains no filler or redundancy. The key operation is front-loaded, and the discard note is compact rather than extra text.

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

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

The tool has nine parameters, no annotations, and no output schema, so the description needs to provide enough context to invoke it. It merely states a high-level check and a discard behavior, but does not explain which parameter is the title, what the successful result looks like, or how this tool should be used relative to siblings.

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 does not add parameter-level meaning, and more importantly it never explains which of the nine schema parameters supplies the Wikipedia title, leaving a critical gap between the described purpose and the actual input shape.

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

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

The description clearly states the operation: check whether a Wikipedia title exists. It uses a specific verb and resource, and it distinguishes the tool from URL/file/shape checking siblings. However, it is not fully actionable because the schema contains no `title` parameter, so the stated purpose is not directly tied to any input property.

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 similar sibling tools, and there is no indication of required conditions or how to pass the Wikipedia title. The description gives only the operation itself, not a selection or invocation strategy.

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 'body discarded', which states the response body is dropped, but it does not disclose read-only behavior, how malformed XML is reported, or why multiple unrelated parameters are accepted.

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

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

The description is six words with no filler, and the key idea is front-loaded. It earns its conciseness, though brevity here comes at the expense of clarity about the tool's actual inputs.

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, so the description is the only source of behavioral context. It is far too sparse to let an agent know how to supply XML, whether the tool is read-only, what response is returned, or which of the 9 fields to populate. The real context is contradictory (XML purpose vs. mixed-input schema).

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

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

Schema coverage is 100%, giving a baseline of 3, but the parameter descriptions are unrelated to XML and describe other tools' concerns (weather hints, timezone names, JSON validation, Git refs). The description itself adds nothing about how these inputs matter to an XML well-formedness check, and there is no XML parameter, so an agent has no dependable way to invoke the tool.

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

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

The description states a specific verb and object: 'XML well-formed check'. It names the resource (XML) and distinguishes itself from the sibling validate-json. However, the schema contains no XML-shaped parameter at all, so the stated purpose conflicts with the actual inputs and an agent cannot tell which field carries the XML to validate.

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 indication of when to use xml-ok versus validate-json, fetch-status, or other shape-check siblings. 'Body discarded' hints at output behavior but provides no context for when this tool is the right choice, no prerequisites, and no exclusions.

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