ISO country GP

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

No annotations are provided, so the description carries the behavioral disclosure burden. It adds useful context: the tool appears read-only in spirit, it is pay-per-call, and task text is discarded. However, it does not disclose auth needs, whether remote MCP hops are invoked, or failure behavior, leaving significant gaps.

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

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

The description is short, front-loaded, and contains no filler; the first sentence identifies the purpose and the second adds return contents and a privacy-relevant discard note. It is slightly too terse to earn a 5 because 'Monid' and the input-output mapping remain unexplained.

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

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

With nine optional parameters and no output schema, the description does not explain which parameters to provide, how they influence the returned artifacts, or what the CLI setup and remote MCP hops actually look like. The per-parameter schema helps, but the overall call pattern is ambiguous.

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

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

Schema description coverage is 100%, so the schema already documents all nine optional parameters. The tool description itself adds no parameter-specific meaning beyond the general note that task text is discarded, so the 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 ('Find') and target ('public pay-per-call tool gateway (Monid)'), and lists concrete returned artifacts (CLI setup, how-it-works, skill file, remote MCP hops). This distinguishes it from the sibling check/hint tools, though 'Monid' and the relationship between inputs and outputs are unexplained, 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?

No guidance is given on when to use this tool versus its many siblings, such as web-fetch, normalize-url, or validate-json. The description does not state preferred scenarios, prerequisites, or exclusions; it only warns that task text is discarded.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It discloses one negative behavior ('No browser is launched') but does not explain whether the check involves a network request, whether it is read-only, what 'can be opened' means, or what happens to the many discarded inputs mentioned in the schema. This is insufficient for a tool with zero annotation coverage.

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

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

The description is extremely concise: two short sentences, no filler, and the key clarification is front-loaded. Both sentences earn their place, and the structure makes the tool's core behavior immediately visible.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, this description is not complete enough. It does not explain the tool's return value, what kind of check is performed, how the unrelated schema parameters relate to the URL check, or whether network access is involved. The agent lacks critical context for correct invocation and interpretation.

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 with individual descriptions. The tool description adds no parameter-level meaning beyond saying 'URL', and it ignores the other parameters entirely. The baseline of 3 applies because the schema does the heavy lifting, but the description does not compensate for the schema's implied diversity of inputs.

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

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

The description states a specific verb and resource: 'Check whether a URL can be opened.' It is not a tautology and adds a useful clarifying note that no browser is launched. However, it does not differentiate from siblings like normalize-url, fetch-status, or playwright-url-ok, and the input schema's many unrelated parameters make the actual scope somewhat ambiguous.

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

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

No guidance is given about when to use this tool versus alternatives such as normalize-url, fetch-status, or playwright-url-ok. 'No browser is launched' is a behavioral note, not a usage rule. The absence of any when-to-use or when-not-to-use language leaves selection entirely to the agent's inference.

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

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

With no annotations, the description carries the full burden, but it only adds 'Expression discarded,' an ambiguous statement. It does not disclose return behavior, side effects, or what the tool does with the nine provided parameters.

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

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

The definition is short and front-loaded, with no filler. However, 'Expression discarded' is ambiguous, and the brevity omits essential information about the input and output.

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 that do not match the description, the tool is not adequately specified. An agent cannot determine what input to provide or what result to expect.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description fails to map any parameter to the arithmetic expression it mentions. The nine optional string fields (ref, url, city, feed, host, json, path, zone, query) are unrelated to 'a+b', so the description adds confusion rather than parameter meaning.

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

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

The description names a specific action ('Evaluate a+b style arithmetic'), but no parameter in the schema corresponds to an expression or operands. The phrase 'Expression discarded' further muddies whether a result is returned, making the tool's actual purpose hard to act on.

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

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

There is no statement about when to use calc-eval, what conditions select it, or which sibling tools are alternatives. Given the large sibling list of shape/URL/query checkers, the agent is left without 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?

With no annotations, the description carries the burden of behavioral disclosure, but it only offers the non-storage guarantee and the output fields. It does not disclose whether the URL is fetched, what side effects occur, or what failure modes exist, leaving important behavior implicit.

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, front-loaded with the primary result and followed by a useful privacy/behavior note. Every word earns its place.

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

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

For a tool with nine optional parameters and no output schema or annotations, this description is too thin: it does not explain which parameter to supply, how the parameters relate to the stated URL behavior, or what an agent should expect in the response. Schema descriptions cover parameter names, but the overall calling context is incomplete.

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

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

Schema description coverage is 100%, so the baseline is 3; the description adds no parameter-level meaning. It only names the URL resource, which aligns with the 'url' parameter but ignores the other eight optional parameters.

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

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

The description states a specific verb ('Return') and resource (URL), and lists three concrete outputs (host, scheme, HTTP status), so an agent can tell what the tool does. It does not explicitly contrast it with sibling tools like normalize-url or fetch-status, so it misses the top score.

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 citation over the many sibling URL/status tools, nor any caveat about prerequisites. 'Page content is not stored' hints at a non-retention use case but does not state when this tool is preferred.

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 for behavioral disclosure. It does add one useful privacy trait: 'No identifiers are retained.' However, it does not disclose whether the tool performs network requests, what side effects might occur, what the classification output looks like, or whether any input is stored even temporarily. The per-parameter 'discarded' notes in the schema already cover much of the retention 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 only two sentences with no filler or repetition; the purpose is stated first and the privacy guarantee second. It is appropriately short from a structural standpoint, though it is under-specified in substance.

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

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

With nine optional parameters, no output schema, no annotations, and a large sibling set, the description is far too sparse. It does not explain what result the agent should expect, which parameters must be supplied, how classification works, or when this tool should be selected over a more specific sibling. The one privacy statement is useful but not enough to make the tool usable.

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

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

Schema description coverage is 100%, so all nine parameters are individually explained in the schema. The tool description adds no parameter-level meaning, does not explain how parameters relate to the classification, and does not indicate which parameters are preferred or mutually exclusive. Baseline 3 is appropriate because the schema already documents each parameter.

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

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

The description uses a specific verb ('Show') and names the resource ('how this request is classified'), so it is not a tautology. However, it does not explain what 'classified' means, what categories are returned, or how 'compatibility' relates to the classification. It also fails to distinguish this tool from the many sibling shape-check and validation tools.

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

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

The description gives no guidance on when to use this tool versus alternatives like validate-json, normalize-url, geo-hint, or file-path-ok. It does not state whether one parameter is expected, whether multiple can be combined, or what prompts or situations should route to compatibility. The 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 present, so the description carries the full burden of behavioral disclosure. It usefully states that WHOIS/ownership data is not included, but it does not disclose that inputs are discarded, that the operation is read-only, what it returns, or how invalid hostnames are handled. The schema notes some discarding behavior, but the description itself is thin.

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

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

The single sentence is readable and front-loaded with the core action. However, for a tool with nine optional parameters and no annotations, this is under-specification rather than useful conciseness. There is no structure or grouping to help an agent understand the parameter space.

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

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

Given nine parameters, no annotations, and no output schema, the description is incomplete. An agent cannot reliably know which parameter to pass, how the parameters interact, what the output looks like, or what edge cases exist. The detailed schema helps but does not compensate for the missing tool-level context.

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

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

Schema coverage is 100%, so each parameter already has a description and the baseline is 3. The tool description adds little parameter-level meaning beyond implying that 'hostname' maps to the host parameter; the other eight parameters are not explained at the tool level. The schema carries the semantic burden.

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

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

The description uses a specific verb ('Split') and resource ('hostname'), and adds the boundary 'without WHOIS or ownership data,' which clearly states what the tool does. However, it does not mention the many unrelated inputs in the schema (url, city, query, etc.) and does not explicitly differentiate from sibling shape tools, so it is clear but not fully contextualized.

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 prefer domain-shape over sibling tools such as url-shape, normalize-url, or fetch-status. The only usage hint is a negative one ('without WHOIS or ownership data'), which tells agents what not to expect but not when to call this tool. For a tool with nine parameters, this is insufficient.

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

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

Annotations are absent, so the description carries the full burden. It discloses the HTTP method and limited output, but fails to mention that the schema accepts 8 other parameters (ref, city, feed, json, path, zone, query) suggesting a much broader scope. No mention of redirects, timeouts, auth, or response format.

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

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

One tight, front-loaded sentence with no filler. It clearly delivers the core action and result.

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

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

With 9 parameters and no output schema, the one-sentence description is insufficient. It does not explain the various parameter modes, how to interpret the returned status, or edge cases. The schema descriptions compensate somewhat, but the description leaves major gaps.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-specific meaning beyond the schema; it only reinforces the url parameter while other parameters remain unexplained by the description.

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

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

States a specific verb (HEAD), resource (public URL), and output (status only). This clearly identifies the primary function, though it doesn't explicitly name sibling alternatives like web-fetch 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?

No guidance on when to use versus alternatives. The phrase 'status only' implies a lightweight use case, but there are no explicit conditions, exclusions, or recommendations to distinguish this from the many sibling URL/status tools.

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

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

With no annotations, the description is the only source of behavioral disclosure. It volunteers one useful trait ('Path discarded'), but it does not say whether the operation is a pure local parse, whether it makes network calls, what happens with an invalid Figma URL, or what output is produced. 'Parse' implies read-only, 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 extremely short and front-loaded, with no filler; every word contributes. It earns high marks for conciseness, though the terse sentence fragment 'Path discarded' could be integrated into a fuller, still concise explanation.

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

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

For a tool with nine parameters, no output schema, no annotations, and many closely related sibling shape/URL tools, one sentence is not enough. The description omits which parameter carries the Figma URL, what the tool returns, and how it differs from normalize-url or browser-url-ok, so an agent cannot reliably invoke it.

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

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

Although the schema has 100% description coverage, its nine optional string properties look like a generic union of sibling-tool parameters (city, feed, host, json, zone, query) and none is explicitly a Figma file URL. The description does not tell the agent which field to populate; 'url' is described only as an HTTPS URL to normalize or cite, and the 'path' property refers to a file path, not a URL path. This ambiguity outweighs the high 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 names a specific verb and resource ('Parse a Figma file URL') and adds a behavioral note ('Path discarded'), so an agent can tell it is Figma-specific rather than a generic URL tool. It does not, however, state what the parsed result is or contrast it with sibling tools like normalize-url or browser-url-ok, so it stops short of full differentiation.

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

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

There is no guidance on when to choose this tool over siblings such as domain-shape, github-repo-shape, normalize-url, or browser-url-ok. The description gives no conditions, exclusions, or prerequisites, so an agent has to infer suitability from the name alone.

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

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

With no annotations, the description carries the behavioral burden, and 'No disk access' is a meaningful side-effect guarantee. However, it does not disclose the return shape, failure behavior, or what 'safe' means, leaving important behavioral gaps.

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

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

The description is two short sentences, front-loads the purpose, and contains no filler or repetition. It is efficient, although the brevity contributes 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 nine optional parameters, no annotations, no output schema, and no required fields, two sentences are insufficient. The agent is left to infer which parameter to supply, what the check covers, and what result to expect, and the unrelated schema parameters make the omission worse.

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

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

All parameters have schema descriptions, so there is baseline information, but eight of the nine parameters describe inputs unrelated to file paths (URLs, city, JSON, zone, search query). The description only references 'path' and never explains which parameter(s) the tool accepts or how they relate, so the high schema coverage does not clarify invocation.

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 ('check whether a path looks safe') and adds a useful constraint ('No disk access'), which loosely separates it from URL/domain siblings. However, 'safe' is undefined, and the schema exposes eight unrelated optional parameters (url, city, json, zone, query, etc.), making the tool's actual scope unclear.

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

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

No guidance is given for when to use this tool instead of siblings like browser-url-ok, domain-shape, or normalize-url. There are no conditions, exclusions, or examples, so the agent must rely on the name and a terse description to make a routing decision.

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

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

There are no annotations, so the description carries the full burden of disclosing behavior. It reveals that Open-Meteo is involved, implying an external lookup, but it does not state whether the operation is read-only, what happens to non-city parameters, whether network access is required, or what errors may occur.

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

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

The description is very short and the key output is front-loaded, which is good. However, it is a noun phrase rather than a complete sentence, and it omits essential selection and behavior details, making it under-specified rather than optimally concise.

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

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

The tool has nine optional parameters, no required parameters, and no output schema, yet the description gives almost no operational context. It does not explain which parameter to provide, what the return value looks like, or how Open-Meteo is queried, so an agent cannot reliably call this tool based on the definition.

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

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

Schema coverage is 100%, so the baseline is 3 even though the description adds no parameter-level detail. The description's mention of 'a place' vaguely aligns with the 'city' parameter, but it does not explicitly map or clarify the role of the other eight parameters.

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

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

The description clearly communicates that the tool returns latitude and longitude for a place, and names the external service (Open-Meteo). It lacks an explicit verb such as 'gets' or 'returns', and it does not distinguish itself from sibling tools, but the core purpose is unambiguous.

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

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

No guidance is provided about when to use this tool versus alternatives, nor which input parameter identifies the 'place'. With nine optional parameters and many sibling tools, the agent is left to infer how to invoke it correctly.

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

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

There are no annotations, so the description carries the full burden of explaining behavior. It only says 'parse,' which implies a read-only operation, but it does not disclose that unrelated parameters are discarded, what happens for invalid or non-GitHub URLs, or whether any lookup or validation is performed. The schema's 'discarded after' hints are not reflected in the description itself.

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

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

The description is one concise, direct sentence with no filler, and the key verb and resource are front-loaded. It loses a point because the minimal structure does not help resolve the ambiguity introduced by the 9-parameter schema with several seemingly irrelevant parameters.

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

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

The tool has no annotations and no output schema, so the description must explain return behavior and relevant inputs. It currently does not state what the parsed owner/repo result looks like, what error behavior occurs for invalid URLs, or which of the many optional parameters actually matter. This makes reliable invocation harder than necessary.

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% parameter description coverage, so the baseline is 3. The tool description adds no per-parameter meaning: it does not explicitly identify url as the GitHub URL to parse, nor does it explain why unrelated parameters like city, feed, json, path, and query are accepted. The parameter descriptions themselves are the main source of information.

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: 'Parse owner and repo from a GitHub URL.' This clearly identifies the tool's function and separates it from sibling shape tools like figma-url-shape and jira-key-shape. The output focus on owner and repo is concrete and 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 implies when to use the tool: whenever an agent needs to extract owner and repo from a GitHub URL. However, it does not explicitly mention alternatives such as normalize-url, browser-url-ok, or other sibling URL tools, nor does it state when not to use this tool.

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

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

With no annotations, the description carries the full burden. It adds a useful behavioral detail—titles are discarded, and the count is of 'current' front-page stories—but it does not disclose return format, failure modes, or whether network access is required.

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

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

Two short sentences with no filler; the primary action is front-loaded and the second sentence provides a meaningful clarification. Every word earns its place.

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

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

The tool has nine parameters, no annotations, and no output schema, so the description must explain how invocation works. It does not state which parameters are relevant, what the return value looks like beyond an implied count, or how errors are handled—significant gaps for an agent.

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

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

Schema description coverage is 100%, so the parameter descriptions already document each field, giving the baseline score. The tool description itself adds no parameter-level guidance, and the relevance of several parameters (city, json, path) to counting HN stories is left unexplained.

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

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

The description uses a specific verb ('Count') and a precise resource ('current Hacker News front-page stories'), and 'Titles discarded' further narrows scope. It is clear and not tautological, though it does not explicitly distinguish itself from sibling tools.

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

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

The described behavior makes it obvious when the tool would be used: whenever a count of current HN front-page stories is needed. However, no explicit conditions, exclusions, or alternative tools are mentioned, leaving the guidance implied rather than stated.

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

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

No annotations are present, so the description must fully disclose behavior, but it does not. It never states what the tool returns, whether there are side effects, or how 'common' zones are determined. The schema's unrelated-looking parameters with 'discarded' descriptions only deepen the opacity.

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

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

The single sentence is concise, but it is under-specification for a tool with nine parameters and no annotations. There is no front-loaded operational summary; the text reads more like a label than a functional description.

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

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

With no annotations, no output schema, nine parameters, and a large set of siblings, this description is far too thin for an agent to invoke the tool correctly. It lacks return format, selection criteria, and any explanation of the parameter payload. The tool cannot be safely chosen or called based on this definition 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 even though the tool description mentions no parameters. The schema already explains each parameter, but the description does not connect any of them to the stated IANA timezone purpose. This is acceptable but adds no extra parameter meaning.

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

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

The description is a noun phrase ('Common IANA timezone names for clock calls') rather than a statement of what the tool does. It adds only the qualifiers 'common' and 'for clock calls' but does not specify whether the tool lists, validates, or returns these names. Sibling tools like 'timezone' and 'utc-time' are not differentiated.

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 a weak hint of context, but there is no explicit guidance on when to use this tool versus alternatives such as 'timezone' or 'utc-time'. No exclusions, prerequisites, or alternative routing are provided, so an agent cannot reliably select it.

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

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

With no annotations, the description carries the transparency burden. It does disclose that only group counts are returned rather than full robots.txt contents, which is useful. However, it does not mention failure behavior for missing/inaccessible robots.txt files, redirect handling, or that many schema parameters appear to be discarded rather than used.

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

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

The description is one short sentence with no filler. It front-loads the action and resource, then states the output constraint. It earns its place despite being minimal.

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, and no annotations, this one-sentence description is incomplete. It does not explain which parameters are actually used, what the returned group counts look like, how failures are reported, or how this tool relates to the many sibling shape/fetch 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?

Although schema coverage is 100%, the parameter descriptions are generic and not tailored to this tool: 'url' is described as 'HTTPS URL to normalize or cite' and 'host' as 'Public hostname', with no indication which one drives the robots.txt fetch. The tool description adds no parameter mapping, leaving an agent to guess between url, host, or possibly another field.

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

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

The description is clear and specific: it names the verb ('Fetch'), the resource ('a public robots.txt'), and the output ('return group counts only'). It does not explicitly differentiate from siblings like web-fetch or fetch-status, but the 'group counts only' qualifier gives enough specificity to avoid confusion with a full-content fetch.

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

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

There is no guidance on when to use this tool versus alternatives such as web-fetch, fetch-status, or normalize-url. The description implies a simple use case but does not state prerequisites, exclusions, or when another sibling would be more appropriate.

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

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

The phrase 'Key discarded' hints that the key is not returned, but the tool's output, side effects, and read-only nature are not described. With no annotations, the agent is left guessing whether it returns a boolean, a validation error, or performs any other action.

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

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

The description is extremely concise and free of fluff, but the brevity comes at the expense of essential details. The structure is minimal and lacks any explanation of the expected input or output format.

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

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

The tool lacks a definition of what constitutes a valid Jira key shape, does not specify which parameter receives the key, and provides no output schema or error behavior. This makes the tool effectively unusable for an agent without additional assumptions.

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 parameters are entirely unrelated to Jira issue keys, with descriptions that seem copied from other tools (e.g., 'Git ref name; discarded after the shape check', 'IANA timezone name'). There is no 'key' or 'issue_key' parameter, making the schema misleading and unusable for the stated purpose.

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

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

The description says 'Check a Jira issue key shape' and 'Key discarded', which conveys the general intent, but it never identifies which input parameter should contain the Jira key. The schema has 9 unrelated optional string parameters (e.g., ref, url, city), so the agent cannot determine what to pass.

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

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

No guidance is provided on when to use this tool versus sibling tools like domain-shape, figma-url-shape, or github-repo-shape. The description does not mention typical use cases, prerequisites, or any alternative selection criteria.

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

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

With no annotations, the description carries the full transparency burden. It does disclose one useful behavior: 'Body discarded' implies only the HTTP status is returned. But it does not reveal that many parameters are also discarded after unrelated checks, and it does not mention potential side effects or network behavior beyond the URL status check.

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

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

The description is concise at two sentences and front-loads the primary action. However, given the tool has nine diverse parameters and no annotations, this brevity is under-specification rather than effective concision; the structure does not help an agent understand the multi-purpose parameter set.

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

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

For a tool with nine parameters, no required fields, no output schema, and no annotations, the description is far from complete. It only covers HTTP status checking for a URL and gives no context for the weather, feed, JSON, query, host, path, timezone, or ref parameters, nor any guidance on return semantics or selection among 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 adds no parameter-specific meaning and actually narrows the tool to a 'public library docs URL', which could mislead the agent into ignoring the other eight parameters. It neither clarifies the relationship between parameters nor compensates for the schema's lack of grouping.

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

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

The description states a clear verb and resource: 'HTTP status for a public library docs URL' and adds that the body is discarded. However, the input schema exposes nine unrelated parameters (city, feed, json, query, etc.) that are not accounted for in this narrow description, so the actual scope is ambiguous and an agent cannot reliably infer what the tool really does.

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

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

The description provides no guidance on when to use this tool versus sibling tools like fetch-status, weather-hint, or validate-json. It neither names alternatives nor states conditions or exclusions, leaving the agent to guess which of many overlapping tools is appropriate.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It does reveal a useful trait: values are discarded rather than returned or retained. However, it omits whether counting is top-level only or recursive, what input is expected, and what the return value looks like, so transparency is partial.

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 tight clauses with no filler, front-loading the core action ('Count keys') and adding one behavioral detail ('Values discarded'). Every word contributes to the tool's 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?

For a tool with nine optional schema parameters, no output schema, and no annotations, this one-sentence description is too thin. It does not specify which parameter holds the JSON input, how nested or top-level keys are counted, what the output format is, or how this relates to sibling validation/shape tools.

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

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

Schema description coverage is 100%, so the baseline of 3 applies even though the description adds no parameter-specific meaning. The schema properties have descriptions, but they are oddly framed as validation/shape-check inputs rather than counting inputs, leaving ambiguity about how to supply the JSON object to count.

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

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

The description clearly states the verb and resource: count keys in a JSON object, and adds that values are discarded. It is specific enough to distinguish this from validation-oriented siblings like validate-json, though it does not explicitly call out any sibling or clarify how the JSON object is passed in the schema.

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

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

There is no guidance on when to use this tool versus alternatives such as validate-json or other shape-checking siblings. The intended use is only implied by the name and the one-line description, with no exclusions, prerequisites, or alternative routing.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal that query and fragment are dropped, which is genuinely useful. However, it says nothing about side effects, prerequisites, or how the many other schema properties relate to the tool's behavior.

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

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

Two tight sentences with no wasted words. The core behavior is front-loaded, making the description easy to parse quickly.

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

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

The description is too minimal for a tool with 9 optional parameters and no output schema. It does not explain the return format beyond naming three URL components, nor does it address why parameters like city, feed, json, zone, and query are present. An agent would struggle to map this description onto the full 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 all parameters are already documented structurally. The description adds behavioral meaning about the URL's query and fragment being dropped, but it does not clarify the role of the other eight parameters in the normalization task.

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

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

The description clearly states the tool's action and output: return origin, host, and path for a URL, and explicitly drops query and fragment. This makes the core purpose unambiguous, though it does not name sibling tools to preempt confusion.

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

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

No guidance is given on when to use this tool versus alternatives like browser-url-ok, web-fetch, or fetch-status. The description implies a URL-normalization use case but never states conditions, exclusions, or alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does reveal that no browser is launched, but it does not explain how the URL is actually checked, whether a network request is sent, what response or success criterion is used, or what side effects or limitations exist. This is barely enough for an agent to reason about 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 two short sentences with no filler. The core purpose is stated first and the key execution detail, 'No browser is launched,' is delivered immediately after. Every word contributes.

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

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

The tool has nine optional parameters, many of which are unrelated to URL checking (e.g., city, json, query), no annotations, and no output schema. The description does not explain how these parameters interact with the check, what the result looks like, or what 'can be opened' means operationally. An agent is left with significant uncertainty about how to invoke this correctly.

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

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

The input schema has 100% description coverage, so the schema already explains each parameter's apparent role. The tool description itself adds no parameter-level meaning. Since the schema carries the load, a baseline score of 3 is appropriate.

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

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

The description uses a specific verb and resource: 'Check whether a URL can be opened.' The additional statement 'No browser is launched' meaningfully distinguishes it from the sibling browser-url-ok, so an agent can separate it from at least one nearby tool. It is not a perfect 5 because 'opened' is still somewhat ambiguous without specifying the mechanism or success criteria.

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 'No browser is launched' implies this tool is the non-browser alternative to browser-url-ok, but the description never explicitly says when to use this tool instead of others like fetch-status or normalize-url. There is no direct when-to-use guidance or exclusion of alternatives.

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

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

With no annotations, the description must carry the burden. It discloses that the query is discarded, which is useful, but it does not mention what the tool returns, how counting treats whitespace/unicode, or what happens if other parameters are supplied. For a simple read-only count tool this is partially adequate but incomplete.

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

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

Two short sentences with no filler. The core action and the discard behavior are front-loaded. It loses a point because the extreme brevity leaves the relationship between the description and the large input schema unexplained.

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

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

Given nine optional parameters, no output schema, and zero annotations, the description is too thin to fully orient an agent. It does not state that only `query` is used, what the return format is, or why the other parameters exist. This is a clear completeness gap for a tool with this schema complexity.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning by clarifying that the operation is a character count on search-query text and that the query is discarded, but it does not reconcile the eight other schema parameters with this 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 states a specific action and resource: count characters in a search query. It is clear enough to distinguish this from URL/path/host checkers, though it does not explicitly mention the `query` parameter by name or address the other eight parameters.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor does it mention that only `query` is relevant while the other parameters are ignored. An agent might wonder whether to pass `url`, `json`, or `ref` because all are optional in the schema.

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

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

With no annotations, the description carries the full burden. It only says 'short catalog', which implies a static reference, but it does not disclose how inputs affect the output, whether it makes network calls, or what response format to expect. Very little behavioral context is provided.

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

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

The description is very short and free of fluff, but it is a fragment rather than a complete sentence. It earns its place yet under-specifies the tool's behavior; it is concise but not appropriately informative.

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 input schema is complex with seven unrelated parameters and no output schema. The one-sentence description provides no guidance on which parameter to use for a given query or what the tool will return. This is completely inadequate for an agent 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 descriptions cover all 7 parameters, so the baseline is 3. The tool description adds no parameter-related meaning, leaving the connection between the params and the status-code catalog unexplained.

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

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

The description states the resource ('common HTTP status codes') and implies a reference catalog with 'catalog'. This distinguishes it from siblings like fetch-status that perform live checks, though it lacks an explicit verb like 'returns' or 'lists'.

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

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

No guidance is given on when to use this tool versus alternatives. It does not mention any conditions, exclusions, or how it relates to sibling tools such as fetch-status or normalize-url.

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 is the sole source of behavioral information. It only vaguely states 'Prompt discarded' without explaining side effects, state changes, or whether the tool is read-only. Key behaviors such as the fate of the input parameters are left 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 extremely brief (two short sentences) and lacks the structure needed to convey the tool's operation. While it is terse, the brevity is not appropriate given the tool's complexity, and the opening phrase 'Return a three-step thinking template' provides no context for the parameters or output.

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

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

Given the tool has 9 parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain what a 'three-step thinking template' is, how the parameters influence it, what the output format looks like, or any constraints. An agent cannot reliably invoke this tool based on the available information.

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

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

The schema provides descriptions for all 9 parameters, meeting the 100% coverage baseline. However, the tool description itself adds no information about how parameters relate to the returned template, and several parameter descriptions (e.g., 'discarded after the shape check') suggest the inputs are irrelevant, which is confusing.

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

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

The description clearly states a specific verb ('Return') and a concrete resource ('a three-step thinking template'), providing a basic understanding of the tool's primary function. However, it lacks any elaboration on the template's content or relevance to the listed parameters.

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

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

No guidance is given on when to use this tool versus any alternative. There is no mention of appropriate use cases, prerequisites, or differentiation from the 26 sibling tools, making it impossible for an agent to select it appropriately.

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 conveys a safe, stateless lookup, but does not mention output format, invalid timezone handling, or that non-zone parameters 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?

A single clear, front-loaded sentence with no filler. It is concise while still conveying the core function.

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

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

Given nine optional parameters and no output schema, the description is too thin. It provides no usage context, no guidance on which parameter matters, and no indication of output shape or edge-case behavior.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description only reinforces that an IANA timezone name is the relevant input, adding no new 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 states the tool's output precisely: the current time for a named IANA timezone. This clearly distinguishes it from sibling tools such as utc-time and iana-zones.

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 instead of alternatives like utc-time or iana-zones. It does not mention prerequisites, valid use cases, or exclusion conditions.

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

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

With no annotations, the description carries the full burden of disclosing behavior, but 'Current UTC timestamp' only states the output concept. It does not specify the return format (e.g., seconds vs ISO-8601), nor does it clarify that all 9 optional parameters are discarded or no-ops.

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

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

The description is a single, front-loaded sentence with no wasted words. It is appropriately compact for a simple utility, though it is too brief to cover the missing behavioral and usage context.

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

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

There is no output schema and no annotation coverage, so the agent needs more context about the return shape and whether any inputs matter. The description does not explain that the tool accepts optional parameters only to discard them, leading to potential confusion about how to call it.

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

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

The schema description coverage is 100%, so the baseline is 3 even though the description adds no parameter information. The property descriptions do document the parameters and note that values are discarded, so the description need not compensate.

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' clearly identifies the tool's purpose and the resource it returns, and the tool name reinforces it. It does not explicitly compare itself to sibling tools like timezone or iana-zones, so it falls short of full differentiation.

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

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

No guidance is given about when to use this tool versus timezone, iana-zones, or other siblings, and there are no exclusions or prerequisites. The description only states what the tool returns, leaving the when-to-use decision entirely to the agent.

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 says the body is discarded. It does not disclose whether the tool is read-only, what it returns (boolean, error, etc.), how invalid JSON is handled, or any other behavioral details.

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

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

The description is very short and does not waste words. However, it is so minimal that it omits important context about usage and output, so while concise, it is not optimally informative.

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 appears simple, but the description does not explain the output format, return value, or error behavior. It also does not account for the many unrelated optional parameters, leaving the overall API contract unclear.

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

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

Although schema descriptions cover 100% of parameters, most of the extra parameters (ref, url, city, feed, host, path, zone, query) have descriptions unrelated to JSON validation, like 'Git ref name' or 'City name for a public weather hint'. These are confusing and likely copied from other tools; only 'json' is semantically relevant.

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

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

The description clearly states that the tool checks whether a body is valid JSON, which is a specific action and distinguishes it from sibling validation utilities. However, it refers to a 'body' rather than tying directly to the 'json' parameter, leaving slight ambiguity about what exactly is validated.

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 the many sibling tools, no context about expected inputs, and no mention of limitations or alternatives. The description only states the action without any usage directions.

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 disclosure burden. It identifies Open-Meteo as the backend but does not describe the return format, units, whether other input parameters are ignored, or any network/statelessness 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 front-loaded sentence with no filler; every word contributes the resource, scope, or source. It is appropriately sized for a simple lookup 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?

With no output schema, no annotations, and a 9-parameter schema where only 'city' seems relevant, the one-line description leaves important gaps: which parameters are used, what the response contains, and what happens when other parameters are supplied. An agent cannot be confident about correct invocation beyond passing a city name.

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 met and the description adds no parameter semantics beyond naming 'city'. It does not clarify that the other eight optional parameters appear irrelevant to the weather lookup, leaving a potential 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 clearly names a specific resource (current temperature for a city) and the data source (Open-Meteo), so an agent can tell it is a weather lookup. It does not explicitly contrast it with sibling tools such as geo-hint, but the function is unambiguous.

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

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

The phrase 'for a city' implies the tool is meant for current-temperature requests, but it does not explicitly say when to use it over alternatives or what to avoid. No exclusions or prerequisites are given.

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

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

With no annotations, the description carries the behavioral disclosure burden. It is transparent that only status and content type are returned and that the body is discarded, which is a meaningful side-effect and privacy trait. It does not address redirects, timeouts, or return format, but the core behavior is clear.

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

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

The description is two short sentences with no filler. It front-loads the core purpose and adds a critical behavioral qualifier ('Body discarded') efficiently.

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

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

Given 9 optional parameters, no annotations, and no output schema, this minimal description is not complete enough. The agent cannot tell which parameter to populate, how the return value is structured, or why the schema contains many unrelated-looking fields.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds no parameter-level meaning. The tool accepts 9 varied optional params, and the description does not clarify that `url` is the operating input or what the other params (ref, city, zone, query) are for. The `url` param description says 'normalize or cite', which conflicts with the stated fetch 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 tool's function: return HTTP status and content type for a public URL, with the body discarded. This is a specific verb and resource. It does not explicitly distinguish from sibling tools like fetch-status, so it misses the top score.

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

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

There is no guidance on when to use this tool versus siblings such as fetch-status, browser-url-ok, or normalize-url. The phrase 'public URL' implies scope, but no alternatives, exclusions, or selection criteria are given.

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

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

No annotations are provided, so the description carries the full burden. It does disclose one behavioral trait: 'Title discarded after the call,' which indicates no retention of the title. However, it omits other important behaviors such as return value, network dependency, or error behavior.

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

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

Two short sentences with no wasted words. The main purpose is front-loaded, and the discard note is a relevant behavioral detail.

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

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

The tool has seven schema parameters, no required fields, no output schema, and no annotations, yet the description does not explain which parameter carries the Wikipedia title or what the tool returns. An agent cannot reliably determine how to invoke this tool correctly.

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

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

The schema has descriptions for all parameters, so the baseline is 3, but the description introduces a 'title' concept that does not map to any schema property. It does not help an agent choose among ref, url, city, feed, host, json, or path, making the input semantics confusing rather than clarified.

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 and resource: 'Check whether a Wikipedia title exists.' It is clear and distinguishable from sibling tools by the Wikipedia-title focus, but it does not explicitly differentiate itself from or reference any sibling tools.

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

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

No guidance is given about when to use this tool versus alternatives such as browser-url-ok, fetch-status, or citation. The description only states what the tool does; it does not mention exclusions, prerequisites, or when-not-to-use.

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