Currency NOK

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

Annotations are absent, so the description carries the disclosure burden. It adds genuinely useful behavioral context: 'Task text discarded' tells the agent that free-form task input is ignored and only structured parameters matter, and it lists what the call returns. However, it does not disclose side effects, rate limits, or whether the 'pay-per-call' nature implies a cost to the caller.

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?

Three short sentences with purpose front-loaded first, return values second, and the behavioral caveat last. Every sentence earns its place; there is zero filler or repetition of schema content.

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

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

With no annotations and no output schema, the description covers the essentials: what the tool finds, what it returns, and that task text is ignored. Remaining gaps are minor in light of 100% schema parameter coverage, though the format of the returned artifacts and cost/rate caveats are not addressed.

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%; each of the six parameters has its own description including per-parameter discard behavior ('discarded after the shape check', 'titles discarded'). Per the rubric this establishes a baseline of 3, and the tool description's 'Task text discarded' merely reinforces what the schema already documents without adding new format or syntax detail.

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 (Find) and resource (public pay-per-call tool gateway Monid), and enumerates the returned artifacts: CLI setup, how-it-works, skill file, and remote MCP hops. This distinguishes it from all 27 siblings, none of which mention tool gateways, Monid, or MCP hops.

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

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

Usage is implied: call this when you need Monid gateway discovery artifacts such as CLI setup or MCP hop information. However, there is no explicit when-to-use/when-not-to-use guidance and no named alternatives among the siblings, leaving appropriate-condition selection to inference.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does disclose a key behavior ('No browser is launched'), but it does not mention whether network requests are made, whether parameters like city/feed/json are discarded, or what the result represents. More detail would be needed for full transparency.

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

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

The description is extremely concise at two sentences, with the core purpose front-loaded and a critical caveat stated immediately. Every word contributes value, and there is no redundancy or filler.

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 broad and heterogeneous input schema (city, feed, json, path, ref) is not explained by the description, creating confusion about the tool's actual scope. There is no output schema and no mention of return values or side effects, leaving an agent under-informed for a tool with this much parameter variety.

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 seven parameters have explicit schemas and descriptions, giving high schema coverage. The tool description itself adds no parameter-level meaning beyond the schema, so a baseline score of 3 is appropriate. It does not clarify why fields like city, feed, or json are relevant to a URL check.

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') and resource ('whether a URL can be opened'), with a meaningful caveat that no browser is launched. It clearly conveys the core function, though it does not differentiate it from sibling tools like playwright-url-ok or 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?

There is no guidance on when to use this tool versus alternatives such as playwright-url-ok, fetch-status, or normalize-url. The only behavioral hint is that no browser is launched, which is useful but does not help an agent decide between similar URL-related tools.

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

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

The description weakly hints at ephemeral behavior with 'Expression discarded,' but with no annotations the description must carry the full behavioral burden. It does not disclose whether the tool is read-only, what side effects exist, or how the expression is supposed to be supplied.

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

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

The text is short and front-loaded with the core action, which is positive. However, 'Expression discarded' is vague and does not earn its place because it obscures rather than clarifies the tool's inputs and 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 no annotations, no output schema, and nine optional-looking parameters that are not mapped to the stated arithmetic purpose, the description is far too incomplete for an agent to invoke this tool correctly. It lacks expression syntax, required inputs, return format, and any connection to the 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?

The input schema has 100% description coverage, but those schema descriptions describe unrelated shape-check/discard behavior across nine unrelated fields. The tool description adds no meaning about any parameter and fails to specify which field, if any, holds the arithmetic expression to evaluate.

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 does state a verb and resource ('Evaluate a+b style arithmetic'), but it never explains what input carries the expression. The added phrase 'Expression discarded' is confusing because the schema has no expression parameter, and the stated purpose does not connect to any of the listed fields.

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 calc-eval versus any sibling tool. The description gives no context about suitable inputs, alternatives, or conditions that would route an agent here rather than to the many specialized validators 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 carries the disclosure burden. It adds one meaningful behavioral trait, 'Page content is not stored,' beyond the basic return values. However, it does not say that the tool fetches or contacts the URL, how redirects or errors are handled, or what the returned HTTP status semantics are.

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

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

Two short sentences, with the primary behavior first and a secondary behavioral note second. There is no filler or repetition of schema data.

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 only covers the URL-status case while the input schema exposes many unrelated-looking optional parameters (json validation, feed, city, path, ref) with no explanation of how they interact. With no annotations and no output schema, an agent lacks enough context to understand edge cases, error behavior, or whether this tool is multi-purpose.

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

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

All 9 parameters have schema descriptions, so the baseline is 3. The description adds no parameter-level insight and does not explain how the URL-related output relates to the other optional fields (ref, city, feed, json, path), but schema coverage meets the threshold.

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

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

The description states a specific verb and resource: 'Return host, scheme, and HTTP status for a URL.' This clearly identifies the core output for a single URL. It does not explicitly differentiate from siblings like fetch-status or normalize-url, 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 'when to use' or 'use instead of' guidance. The note that page content is not stored implies a lightweight/privacy-preserving use, but it does not say when to choose this tool over browser-url-ok, web-fetch, or fetch-status, and it gives no 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?

Since no annotations are provided, the description carries the full disclosure burden. It does disclose a meaningful privacy trait—'No identifiers are retained'—which the parameter descriptions reinforce. However, it does not state whether any external calls occur, what the classification output looks like, or whether there are side effects, so transparency is only 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 only two short sentences with no redundant wording, and the privacy disclaimer earns its place. The first sentence is vague, but the overall text is appropriately compact.

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, the description is too thin. It does not explain what output the classification produces, how the parameters map to classification outcomes, or how it fits alongside the sibling tools. The schema descriptions help, but the tool-level description leaves critical operational context missing.

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

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

Schema description coverage is 100%, so the structured schema already documents all nine optional parameters. The tool description adds no parameter-level meaning beyond the schema, meeting the baseline but not compensating with examples or parameter relationships.

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 an action ('Show') and a resource ('how this request is classified'), so it is not a tautology. However, it never defines what classification categories are produced or what 'request' refers to, leaving the tool's core purpose under-specified. It also does not differentiate itself from the many sibling shape/classification tools.

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

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

There is no guidance about when to use this tool instead of siblings such as domain-shape, validate-json, or file-path-ok. No alternatives, preconditions, or exclusions are mentioned. Usage is only weakly implied by the verb 'Show'.

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 states the core split operation and a negative constraint, but it does not explain the output format, whether network access occurs, how the nine optional parameters are handled, or what happens when the hostname is invalid.

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

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

The description is one short, front-loaded sentence with no filler. Every word contributes either the operation or a meaningful limitation.

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 a 9-parameter schema and no output schema, the description does not specify which parameter to supply, what the returned labels look like, or any error/edge-case behavior. An agent would have difficulty confidently invoking this tool correctly without additional context.

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

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

Schema description coverage is 100%, so each parameter is already documented. The description adds a useful hint that 'hostname' maps to the host parameter, but it does not clarify the role of the other eight accepted parameters or how they relate to this tool. 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 names a specific verb and resource: split a hostname into labels. The qualifier 'without WHOIS or ownership data' helps distinguish it from ownership/enrichment tools, though it does not explicitly contrast it with sibling URL- or hostname-related tools.

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

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

There is no guidance about when to use this tool instead of normalize-url, browser-url-ok, playwright-url-ok, or similar siblings. The 'without WHOIS or ownership data' phrase implies a non-enrichment use case, but no explicit when/when-not or alternative is given.

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

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

The description discloses the HTTP method (HEAD), the input constraint (public URL), and the output limitation (status only), which is useful given there are no annotations. However, it leaves redirect/timeout/error behavior and the exact status format unspecified, and there is no output schema to fill that gap.

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

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

The description is a single sentence, front-loaded with the method and output, with no wasted words. It is appropriately concise for a simple status-check tool.

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

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

There is no output schema or annotations, the input schema exposes nine optional parameters that appear geared to sibling shape-check tools, and there is no guidance on return value format or alternatives. A one-line description is insufficient for an agent to confidently know which parameters are relevant and what 'status' looks like.

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

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

Schema descriptions cover 100% of 9 optional parameters, so the baseline is 3. The description adds the crucial context that a URL is HEADed for status, but it does not say which parameter(s) to populate or that the other fields are irrelevant; the `url` property description ('normalize or cite') is also not aligned with fetch-status.

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

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

The description uses a specific verb ('HEAD') and resource ('a public URL') and states the narrow output ('status only'), which clearly separates it from content-fetching siblings like web-fetch. It does not name a sibling, but 'status only' establishes the tool's unique scope.

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 'public URL' and 'status only' imply when to use this tool, but there are no explicit when-to-use/when-not-to-use statements or named alternatives despite a large sibling set (browser-url-ok, web-fetch, normalize-url). The guidance must be inferred 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 carries the full burden of behavioral disclosure. It only mentions that the path is discarded; it does not say whether the tool returns a boolean, parsed components, or an error, nor whether it is read-only or validates the URL. With nine parameters and no output schema, the behavioral transparency 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 just two short sentences and is front-loaded with the core action. Every word earns its place, and there is no fluff or redundant content. The phrase 'Path discarded' is terse but does convey an important limitation.

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 high parameter count (9), no required parameters, no output schema, and no annotations, a two-sentence description is not enough for an agent to invoke the tool reliably. It does not specify the return format, which parameter is required for the Figma URL, or how this tool differs from other URL/shape tools. The agent would likely need to infer or probe.

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

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

Schema description coverage is 100%, so each parameter has some description, which meets the baseline. However, several parameter descriptions are generic and not tailored to Figma URL parsing (e.g., url is described as 'HTTPS URL to normalize or cite'). The main description does help by indicating that the relevant input is a Figma file URL and that the path is discarded, but it does not add substantial meaning beyond the schema.

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

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

The description states a specific verb ('Parse') and a specific resource ('a Figma file URL'), which allows an agent to distinguish it from generic URL tools and other shape-check tools. 'Path discarded' adds a scope constraint, though it is somewhat cryptic. The tool name reinforces the shape-check purpose.

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

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

There is no guidance about when to use this tool instead of related siblings like normalize-url, playwright-url-ok, github-repo-shape, or domain-shape. The description does not mention exclusions, prerequisites, or conditions under which this tool is preferred. Usage is left entirely to inference from the name.

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

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

The description explicitly discloses 'No disk access,' which is a meaningful behavioral trait and helps distinguish this from filesystem-touching operations. However, with no annotations and no output schema, it does not explain what the tool returns or what criteria determine whether a path 'looks safe.' The transparency is partial rather than 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 extremely concise: two short sentences with the primary action front-loaded and the key constraint second. There is no filler or repetition. It borders on under-specification, but as a piece of concise writing it is well-structured and efficient.

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, the description is too thin. It fails to define the return value, the meaning of 'safe,' or how the path parameter relates to the many other fields in the schema. An agent cannot fully determine how to invoke the tool correctly or interpret its result.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description does not add semantic value beyond restating the concept of checking a path, and it does not clarify whether the other eight optional parameters are relevant or ignored. 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 clearly states the tool's function with a specific verb and resource: 'Check whether a path looks safe.' The additional note 'No disk access' adds useful scope, and the name file-path-ok reinforces the purpose. However, 'safe' is left undefined and there is no explicit contrast with sibling shape-check tools.

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

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

The description gives no guidance on when to use this tool versus the many sibling checkers such as browser-url-ok, wiki-title-ok, or normalize-url. It only states what it does, leaving the agent to infer the appropriate context. No alternatives, exclusions, or conditions are mentioned.

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

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

No annotations are provided, so the description must carry behavioral disclosure. It does reveal that the tool relies on Open-Meteo (an external API), implying a network read, but it does not describe input-discarding behavior, error conditions, or output format; the schema's 'discarded' notes are not part of the description.

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

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

The description is a single front-loaded sentence with no filler. It is too terse, however, to compensate for nine optional parameters and no annotations; the brevity reads as under-specification rather than efficient economy.

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 output schema, no annotations, and a heterogeneous nine-parameter input schema, the description is insufficient for confident invocation. An agent cannot determine which parameter to populate, what the response looks like, or whether irrelevant parameters are safely ignored.

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 has a description, but the description adds no parameter-level guidance. The term 'place' reasonably maps to the 'city' property, yet the city description mentions 'public weather hint' rather than geocoding, so the mapping is not as crisp as it could be.

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 (latitude and longitude for a place) and the method (Open-Meteo), which is enough to identify it as a geocoding tool and distinguish it from siblings like weather-hint. It lacks an explicit verb such as 'returns', but the intent 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 about when to select geo-hint over weather-hint or timezone, and no mention of which sibling covers weather or coordinates. The description only states the tool's function, leaving tool routing 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. "Parse owner and repo" implies a read-only operation, but the description does not state error behavior, response shape, side effects, or whether inputs are truly discarded. The schema's "discarded" phrases hint at non-persistence, but the tool description itself adds little behavioral transparency.

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

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

The description is a single focused sentence with no filler. It front-loads the core action, input, and output. It could not be more concise while still stating the purpose.

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

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

The tool has 9 parameters, no required parameters, no annotations, and no output schema. The description names the expected output (owner and repo), but it does not specify which parameter to provide, whether non-GitHub URLs are rejected, or what happens when irrelevant parameters are passed. The clutter of unrelated schema fields makes the definition incomplete for an agent deciding 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?

Schema description coverage is 100%, so the baseline is 3. The description adds important meaning by implying the url property should be a GitHub URL, but it does not explain the relationship of the other eight parameters to the parsing task. Schema descriptions cover individual fields, but the description does not resolve why city, feed, json, path, and query are present.

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

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

The description states a specific verb and resource: "Parse owner and repo from a GitHub URL." This clearly distinguishes it from siblings like figma-url-shape and jira-key-shape. However, the input schema includes many unrelated properties (city, feed, json, path, query), and the url property is described generically as "HTTPS URL to normalize or cite," which slightly undermines the stated GitHub-specific purpose.

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

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

There is no guidance about when to use this tool instead of siblings such as normalize-url, domain-shape, or other URL/shape validators. No required parameters are indicated, so an agent cannot tell whether url is mandatory or what to do if multiple fields are provided. The description leaves usage context entirely to inference.

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

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

No annotations are present, so the description carries the full burden. It only discloses that titles are discarded, but does not say whether this is a live network read, what happens on failure, or what exactly is being counted. The behavioral disclosure is too thin for a tool with no annotation support.

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

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

Two short, front-loaded sentences with no filler. The core purpose is stated first, and 'Titles discarded' adds a meaningful behavioral note in very few words.

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

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

Given nine optional parameters, no output schema, and no annotations, the description leaves too much unstated: what the tool returns, whether it accesses the live HN site, and which parameters affect behavior if any. This is not enough context for reliable invocation in varied situations.

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

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

Schema coverage is 100% and all parameters are optional, so the schema already documents each field. The description adds no parameter-specific guidance and never clarifies whether any of the nine optional parameters matter, or whether the tool should be called with no arguments. Baseline 3 applies because the schema handles parameter documentation.

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

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

The description states a specific verb and resource: 'Count current Hacker News front-page stories.' This is clear and actionable. It does not explicitly contrast itself with sibling tools, so it stops just short of a top-tier purpose statement.

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

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

There is no guidance about when to use this tool versus alternatives. It does not mention prerequisites, exclusions, or a decision condition; an agent must infer entirely from the name and description when this tool 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, the description carries full behavioral burden, but it only says the tool is for 'clock calls' and lists common IANA timezone names. It does not disclose return format, whether parameters are ignored, whether this is a read-only operation, or any side effects. The schema's 'discarded' hints appear only in parameter descriptions, not in the tool description.

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

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

The description is a single short sentence, but it is under-specified rather than concisely informative. It lacks an action verb and any structural guidance that would help an agent understand how to invoke the tool, so the brevity does not earn its place.

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

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

For a tool with 9 optional parameters, no annotations, and no output schema, this description is severely incomplete. It does not specify which parameters to supply (if any), what the return value should be, or how this tool fits into the clock/timezone workflow alongside siblings like timezone and utc-time. An agent cannot correctly select or invoke this tool from this definition.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds no parameter-level meaning, and the schema descriptions themselves are detailed but unrelated to timezone names, creating confusion. The description does not compensate for the apparent disconnect between the tool's stated purpose and its input 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 'Common IANA timezone names for clock calls' is a noun phrase with no action verb; it does not state whether the tool returns a list, validates a timezone string, or performs a lookup. It vaguely distinguishes from timezone/utc-time siblings but not clearly, and the input schema's unrelated parameters (ref, url, city, etc.) further muddy the purpose.

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

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

There is no guidance on when to use this tool versus alternatives like timezone or utc-time. No mention of when not to use it, no reference to sibling tools, and no context for how the 9 optional parameters should be chosen or ignored.

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

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

With no annotations, the description must carry the behavioral burden. It does disclose that the operation is a read/fetch of a public resource and that the response is limited to group counts. But it omits failure behavior, handling of missing or invalid robots.txt, and network or auth implications.

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

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

One short sentence with no filler; the action is front-loaded and the output constraint ('group counts only') is packed into a few words. Every word earns its place.

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

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

The definition is incomplete for correct invocation: there are 9 optional, unrelated parameters with no guidance on which one specifies the target robots.txt, no output schema, and no annotations. The description states what is returned but not the input contract or edge-case behavior needed to call it reliably.

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 baseline 3 applies even though the description adds no parameter details. The parameter descriptions are individually clear (e.g., url, host), but none of them explicitly ties a parameter to the robots.txt URL, so the tool-specific mapping remains ambiguous.

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

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

The description names the action ('Fetch'), the target resource ('a public robots.txt'), and the exact output ('return group counts only'), which distinguishes it from generic fetching tools like web-fetch. This is specific enough to tell an agent what the tool is for.

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

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

Usage is implied: an agent should choose this tool when it needs robots.txt group counts rather than raw robots content. However, the description gives no explicit context, no when-not-to-use conditions, and does not mention alternatives from 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?

Without annotations, the description carries the transparency burden. 'Key discarded' discloses that the input is not retained and the operation is a pure check, but it does not explain the return value, failure behavior, or whether a network call is involved. Some transparency is present, but the full behavioral contract is missing.

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 redundant wording. The action is front-loaded, and 'Key discarded' adds a useful behavioral note without extra fluff.

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

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

For a tool with no output schema and no annotations, the description should at least identify the parameter to pass and what result to expect. It does neither, and the large unrelated schema makes the invocation ambiguous. The simple intent is clear from the name, but the operational details needed to call the tool correctly are missing.

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

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

Although the schema has 100% description coverage, the description never connects 'the key' to any of the 9 schema properties. The schema lists ref, url, city, feed, host, json, path, and others, none of which is described as a Jira issue key, so an agent cannot confidently determine which parameter to populate. The 'Key discarded' phrase adds no parameter-level mapping.

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 ('Check') and a specific resource ('Jira issue key shape'), and the name separates it from sibling shape-checkers like github-repo-shape and domain-shape. It stops short of a 5 because it does not specify what 'shape' means or what a valid result looks like, leaving some ambiguity.

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 siblings such as github-repo-shape, wiki-title-ok, or normalize-url. The intended use is only implied by the tool name and the phrase 'Jira issue key shape'; no exclusions or alternative conditions are stated.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses that the body is discarded, but it does not state whether the operation is read-only, how redirects or errors are handled, or what side effects if any occur. The mismatch between the URL-focused description and the many discarded input fields further reduces transparency.

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

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

The description is brief and front-loaded, with no filler words. However, for a tool with nine optional parameters and no annotations, this brevity edges toward under-specification rather than ideal 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?

There is no output schema and no annotations, so the description must explain both return behavior and parameter selection. It only addresses the docs-URL use case, leaving the other eight parameters and their outputs unexplained, and it fails to position the tool among its many 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 schema already documents each parameter's meaning and discard behavior. The description adds no parameter-level detail and does not clarify which of the nine parameters should be used for the stated docs-URL purpose, but the baseline of 3 applies because the schema carries the load.

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 outcome (HTTP status) for a specific resource (a public library docs URL) and notes that the body is discarded. However, it does not differentiate this from sibling tools like fetch-status or browser-url-ok, and the broad 9-parameter schema suggests a wider purpose than just docs-URL status checking.

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

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

The description provides no guidance on when to choose this tool over alternatives, no prerequisites, and no exclusion criteria. 'Body discarded' hints at a status-only use case, but it never names siblings or explains when not to use it.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure, but it only states that values are discarded. It does not say whether the operation is read-only, how keys are counted (top-level vs nested), what happens on invalid input, or what the return value will be.

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 action is front-loaded and the discarded-values note earns its place. Nothing could be removed without losing 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?

There is no output schema and no annotations, so the description should explain the input source and return format. It leaves ambiguities about parameter mapping, recursion depth, and the result, making it incomplete for reliable invocation.

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

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

Schema description coverage is 100%, so parameter details are available in the schema itself and the description need not repeat them. However, the description does not clarify which parameter supplies the JSON object or reconcile the schema's 'json' field saying 'validate' with the tool's counting 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 names a specific verb and resource: count keys in a JSON object, and adds that values are discarded. This makes the core intent clear, though it does not explicitly differentiate itself from sibling tools like validate-json.

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 choose this tool instead of validate-json or other sibling tools, and no exclusions or conditions are mentioned. Usage is only implied by the phrase 'Count keys', which 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?

With no annotations, the description is the only source of behavioral disclosure. It usefully states that query and fragment are dropped, but it does not mention that several input parameters (city, feed, json, zone, etc.) are accepted only to be discarded, whether any network access occurs, or what happens on invalid input.

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

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

Two sentences deliver the core behavior with no filler, and the most decision-relevant information ('origin, host, and path'; 'query and fragment are dropped') is front-loaded. This is a model of concise writing, even if other dimensions need more content.

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

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

For a tool with 9 parameters, no output schema, and a large sibling set, the description is too sparse. It doesn't specify the return format, which parameters actually participate in normalization, how unrelated parameters are treated, or how this differs from sibling URL tools.

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

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

Schema description coverage is 100%, so the schema already documents all 9 parameters; the description adds no parameter-level meaning. Baseline 3 applies, though the description's 'query and fragment dropped' only loosely aligns with the query parameter's 'discarded after the length check' 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?

Description names a concrete output ('origin, host, and path') and a verb ('Return') tied to URLs, making the core operation clear. It doesn't explicitly contrast with sibling URL tools like browser-url-ok or figma-url-shape, but the stated scope is specific enough.

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 prefer this tool over the many sibling URL/shape tools, nor are exclusions or prerequisites mentioned. The intended invocation context must be inferred entirely from the tool name and the terse behavior statement.

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

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

With no annotations, the description carries the full burden. It discloses that no browser is launched, but does not explain what 'can be opened' means (e.g., HTTP status, network request), possible side effects, rate limits, or the return value.

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, front-loaded sentence efficiently communicates the core purpose and a key behavioral trait. It is appropriately concise for a simple check tool, though it lacks structured 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 no annotations or output schema, and the description covers only the basic premise. Given the broad input schema with multiple unrelated-looking fields, the description is insufficient for an agent to fully understand how to invoke the tool correctly (e.g., which input to provide, expected output format).

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

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

The input schema has 100% coverage with descriptions for every parameter, so the baseline is 3. The description adds no parameter-specific context beyond what's in the schema, and it does not clarify which parameter is the primary URL to check among the many optional-looking fields.

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

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

The description clearly states a specific action ('Check whether a URL can be opened') on the URL resource. The key differentiator 'No browser is launched' helps distinguish this from the sibling browser-url-ok, even without naming it.

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 implicitly suggests a lightweight check by noting no browser is launched, which implies it might be preferred over browser-url-ok for faster checks. However, it does not explicitly state when to use this tool versus alternatives or mention any 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?

There are no annotations, so the description carries the full burden. It does disclose that the query is discarded, implying no persistence or real search behavior, and 'count characters' suggests a pure read-only operation. However, it does not clarify behavior for the other eight schema parameters or mention any error conditions.

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

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

The description is very concise: two short sentences with the main purpose front-loaded. The second sentence 'Query discarded' adds meaningful behavioral information without waste. It is slightly under-specified, but not 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?

Despite 100% schema coverage, the tool has nine optional string parameters with no output schema and no annotations. The description does not clarify that only 'query' is relevant, what happens with the other parameters, or the return format. This ambiguity makes the definition incomplete for confident invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning beyond the schema; it only mentions 'a search query' while the schema already describes the query parameter in detail. This is adequate but not additive.

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 operation: 'Count characters in a search query.' This is a specific verb plus resource. It does not explicitly contrast with siblings like memory-key-count or hn-front-count, so it misses full sibling differentiation, 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?

The description gives no guidance about when to use this tool versus alternatives, nor does it mention when not to use it. It only states the operation, leaving the agent to infer appropriate usage from the tool name and 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 provided, the description carries the full burden of behavioral disclosure, but it only states that the catalog is 'short' and 'common'. It does not disclose return format, side effects, authentication needs, or how the nine input parameters relate to behavior. This is a serious transparency gap for a tool with no structured annotation support.

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

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

The description is extremely short, but this is under-specification rather than effective conciseness. It front-loads only the vague notion of a 'short catalog' and provides no actionable structure. Every word is low-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?

The tool has nine optional parameters, no output schema, and no annotations, yet the description explains none of these aspects. There is no indication of what the tool returns, how inputs are used, or what 'catalog' means operationally. This is incomplete for an agent to select and 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 schema already documents each parameter individually, including notes like 'discarded after the shape check'. The tool description adds no parameter-level meaning of its own, but the baseline of 3 applies because the schema carries the burden. The tool description's failure to connect parameters to the catalog concept is a missed opportunity but not a scoring penalty beyond 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 'Short catalog of common HTTP status codes' identifies the resource (HTTP status codes) but uses no verb and reads as a noun phrase restating the tool name. It does not specify what operation is performed, e.g. whether it returns the catalog, looks up a code, or validates a status. It also does not distinguish itself from siblings like fetch-status or browser-url-ok.

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

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

No guidance is given about when to use this tool versus the many sibling tools. There is no mention of alternatives, prerequisites, or intended use cases. An agent is left to infer whether status-catalog is for looking up status codes, checking URL status, or something else entirely.

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

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

With no annotations, the description carries the full behavioral burden, but it only discloses that the prompt is discarded. It does not clarify whether the nine listed parameters are genuinely used or all ignored, and it never states that the call is read-only or side-effect-free. The schema descriptions for parameters like 'url' and 'json' imply processing, which makes the 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 short and front-loaded, with no filler sentences. However, it is under-specified for a tool with nine optional parameters and no output schema, so the brevity sacrifices useful context rather than being a model of efficient completeness.

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

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

The description does not explain what the three-step template contains, whether callers should pass any parameters, or what happens if multiple parameters are provided. With no output schema and no annotations, an agent is left without enough context to invoke the tool confidently beyond a blind no-argument call.

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 only the phrase 'Prompt discarded', which is ambiguous given that the schema describes parameters such as 'url', 'json', and 'path' with apparent purposes. It neither contradicts nor substantially improves the schema-provided 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 gives a concrete action ('Return') and a concrete deliverable ('a three-step thinking template'), and adds that the prompt is discarded. This makes the tool's core function reasonably clear, though it does not detail what the template contains or explicitly differentiate from sibling tools.

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

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

There is no explicit guidance on when to use this tool versus alternatives, and no mention of a typical use case such as structuring reasoning before tackling a complex request. 'Prompt discarded' hints at what not to expect, but it does not say when the tool 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description only states the outcome and does not mention whether this is a read-only lookup, how the timezone is resolved, what output format is returned, or that the schema parameters are discarded. The schema's descriptions suggest unrelated shape-checking behavior, adding confusion rather than transparency.

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

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

The description is a single, direct sentence with no filler or repetition. It front-loads the core purpose and is appropriately concise for a simple lookup tool. The brevity itself is not the problem; the missing parameter alignment is.

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

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

The definition is not complete enough for reliable invocation: there is no way to specify the named timezone, no output schema, no annotations, and no explanation of the unrelated input parameters. The mismatch between the description and the schema is severe enough that an agent could not confidently call this tool based on the provided definition.

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

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

The description refers to a named IANA timezone, but the input schema has no timezone parameter and additionalProperties is false, meaning the necessary argument cannot be supplied. The schema parameters are described as Git refs, URLs, city names, feeds, hosts, JSON, and file paths, none of which relate to selecting a timezone. The description adds no usable parameter semantics and actually conflicts with the schema.

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

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

The description clearly communicates that the tool returns the current time for a named IANA timezone, which distinguishes it from sibling tools like utc-time and iana-zones. It lacks an explicit verb such as 'gets' or 'returns', but the meaning is unambiguous. However, this stated purpose is not reflected in the input schema, which undermines the clarity when the agent tries to use the tool.

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 'named IANA timezone' implies when the tool should be used, and the sibling names suggest alternatives like utc-time and iana-zones. There is no explicit when-to-use or when-not-to-use guidance, nor any mention of alternatives. The agent is left to infer the usage context from the description and tool names 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only states the output ('current UTC timestamp') and does not reveal how the tool handles the seven input parameters, whether they are discarded, what format the timestamp uses, or that no side effects occur. The schema hints at discarded values, but the description itself offers no behavioral transparency.

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

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

The description is a single short sentence with no wasted words. It is front-loaded and concise, though it sacrifices detail for brevity.

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 a surprisingly large parameter list, the description is not complete enough for correct invocation. It fails to specify timestamp format, parameter handling, or the fact that the tool likely needs no meaningful arguments. An agent could easily misuse the tool by passing one of the seemingly relevant parameters.

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

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

All seven parameters have descriptions in the input schema, so schema coverage is high. The tool description adds no parameter-level meaning beyond what the schema already provides, which matches the baseline of 3. However, the relevance of these parameters to a UTC-timestamp tool remains 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 clearly states the tool returns the current UTC timestamp. However, it is a noun phrase without an explicit verb/action and does not differentiate this tool from sibling time-related tools such as timezone or 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?

The description gives no guidance on when to use this tool versus alternatives, no mention of optional parameters, and no exclusions. There is no indication that parameters like url, json, or path are ignored or irrelevant, so an agent cannot decide confidently when to invoke 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?

The only behavioral trait disclosed is that the body is discarded after validation. With no annotations provided, the description carries the full burden, but it does not mention return values, error behavior, or whether validation succeeds/silently fails. This is a meaningful gap for a tool whose sole job is validation.

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 meaningful behavioral note about discarding the body. 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?

Given there is no output schema and no annotations, the description should explain what the tool returns or indicates about validity. It does not. The schema lists many parameters, but the description does not clarify how to supply the JSON body or what happens beyond discarding it, leaving significant context missing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds little beyond the schema, though it does introduce the concept of a 'body.' The relevant 'json' parameter is already documented clearly in the schema, so no major parameter-semantics gap exists.

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 body is valid JSON. It names the resource type (JSON) and the specific action, which distinguishes it from the many sibling URL/shape/check tools. The purpose is unambiguous.

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

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

The description implies usage: use this when you need to validate JSON. However, it gives no explicit guidance on when not to use it or how it compares to alternative validation tools, leaving usage conditions largely implicit.

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

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

With no annotations, the description must carry behavioral disclosure. It reveals an external call to Open-Meteo but does not explicitly state that the operation is read-only/stateless, how unknown cities are handled, or what the returned temperature looks like (e.g., numeric value, units).

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

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

The description is a single sentence with no filler and is front-loaded with the key action. It is concise, though slightly under-specified for the tool's actual schema breadth.

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

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

The tool has 9 optional parameters, no annotations, and no output schema, but the description only addresses city weather. It does not explain the purposes of the other eight parameters, whether they are supported, or how to interpret the absence of required parameters, making the definition incomplete for safe invocation.

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

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

Schema description coverage is 100%, so the schema already documents all parameters, including 'city' and the discarded behavior. The description names 'city' but adds no parameter meaning beyond the schema, so the baseline of 3 applies.

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

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

The description clearly states that the tool returns the current temperature for a city via Open-Meteo, giving a specific resource and data source. It distinguishes weather-hint from sibling time/geo/validation tools, though it lacks an explicit verb like 'returns'.

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

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

Usage is implied: if a user asks for the current temperature of a city, this is the tool. However, it does not explicitly say when to prefer it over alternatives or note that only the 'city' parameter is relevant, and the broad schema with 9 optional parameters leaves correct invocation ambiguous.

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

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

With no annotations, the description must carry behavioral disclosure. It usefully discloses that the body is discarded and limits scope to public URLs, but it never mentions that the other schema properties (city, ref, json, path, feed, host) are ignored or how the tool behaves on redirects, errors, or timeouts.

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 sentence front-loads the core output and the body-discarded caveat; there is no filler. It is concise, though given the messy schema, a little more structure would have been 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?

For a 7-parameter tool with no annotations and no output schema, this one-liner is incomplete. It does not say which parameters are accepted/ignored, what the return shape is, whether a URL is required, or how this differs from nearby sibling tools.

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

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

The schema already describes every parameter, so the baseline is 3. However, the tool description adds no parameter-level guidance, and several schema descriptions conflict with the stated purpose (e.g., url is 'to normalize or cite', feed titles 'discarded', path is 'file path to check'), leaving the actual input for the fetch ambiguous.

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

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

The description names a specific action and resource: retrieving HTTP status and content type for a public URL, and explicitly says the body is discarded. That is clear enough to distinguish it from a general content-fetching tool, though it does not reference 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?

No guidance is given about when to use web-fetch rather than the many URL/checking siblings (fetch-status, browser-url-ok, normalize-url). The description does not state required parameters, exclusions, or which schema properties actually drive the call.

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 one useful trait—'Title discarded after the call'—indicating statelessness/non-retention. However, it does not state the return format, error behavior, network dependency, or how a failed lookup is represented.

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

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

Two short sentences with the main purpose front-loaded and the statelessness caveat second. There is no filler, redundancy, or repetition of schema field names.

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 schema is complex with seven unrelated parameters and there is no output schema, so the description must do more to enable correct invocation. It fails to identify which parameter carries the Wikipedia title or what the result looks like, leaving a critical gap.

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

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

The description references 'a Wikipedia title,' but the input schema exposes no title parameter—only ref, url, city, feed, host, json, and path. With schema-description coverage at 0%, the description does not compensate and leaves the agent unable to map the described action to any concrete 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 action—'Check whether a Wikipedia title exists'—and a concrete resource, so the core intent is clear and distinguishable from sibling URL/shape checkers. It does not explicitly name alternatives, but the meaning is not tautological.

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

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

No guidance is given on when to use this tool versus siblings like web-fetch, normalize-url, or validate-json. The description only implies a Wikipedia-title existence check, with no exclusions, prerequisites, or alternative-selection conditions.

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