Currency IDR

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

Annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false), so the description only needs to add non-obvious behavior. It does: it enumerates the returned artifacts and explicitly states 'Task text discarded', signaling input content is not retained. This is consistent with the read-only annotations — no contradiction.

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 terse sentences, each earning its place: purpose, return artifacts, and input-discard trait. The primary purpose is front-loaded in the first sentence, and there is no 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 output schema, the description helpfully enumerates return artifacts, and annotations cover the safety profile. However, it assumes agent familiarity with 'Monid' and 'MCP hops' without elaboration, and gives no guidance on how to route to this tool versus the large sibling set. Adequate but not fully self-contained.

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 (ref, url, city, feed, host, json) already has its own schema-level description, including discard notes. The description adds no parameter-level meaning, so the baseline-3 score 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 opens with a specific verb and resource — 'Find a public pay-per-call tool gateway (Monid)' — and lists the concrete deliverables (CLI setup, how-it-works, skill file, remote MCP hops). This clearly differentiates it from all sibling tools (web-fetch, normalize-url, status-catalog, etc.), none of which index gateways.

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 purpose statement implies the context — use this when you need a public pay-per-call gateway — but there is no explicit when-to-use guidance, no exclusions, and no named alternative among the 27 siblings. 'Task text discarded' is a behavioral note, not routing 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 full burden. It usefully discloses the key behavioral trait of not launching a browser, but it does not say whether a network request is made, what inputs are accepted, or what happens on success or failure.

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

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

Two short sentences, front-loaded, with no filler. Every word earns its place and the core behavior is stated first.

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

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

Despite the concise opening, the tool is complex with 7 heterogeneous parameters, no annotations, and no output schema. The description leaves core semantics undefined: the agent cannot tell why non-URL parameters exist, what 'can be opened' means, or what the return value is.

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 properties have descriptions in the schema, so parameter coverage is high and the baseline is 3. The description adds no parameter detail, and it actually creates a mismatch by focusing only on URL while the schema includes ref, city, json, path, and other heterogeneous parameters, leaving the agent without guidance on how those relate.

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 clear verb ('Check') and resource ('whether a URL can be opened'), and the second sentence distinguishes it from browser-launching tools. However, 'can be opened' is ambiguous (syntax vs. network reachability vs. browser compatibility), and it does not differentiate from normalize-url or domain-shape.

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

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

The description gives no explicit when-to-use guidance or alternatives. 'No browser is launched' hints at a contrast with browser-based tools like playwright-url-ok, but it never names that sibling or states when to prefer this tool. Usage context is only implied.

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 already declare readOnly, non-destructive, idempotent, and safe, so the bar is lower. The description adds 'Expression discarded', which hints that no durable effect or result is retained, but it still leaves the actual behavior unclear: the schema says inputs are used for shape checks, not arithmetic evaluation.

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 are concise, but the content is not appropriately scoped: it omits all operational detail for a tool with seven parameters. The second sentence, 'Expression discarded', causes confusion and 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?

With no output schema and no return-value explanation, the description needed to explain what the tool returns or confirms, how an expression is supplied, and which arguments are valid. It does none of this, and its arithmetic framing is incompatible with the schema, leaving the tool effectively uncallable from the description alone.

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

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

The schema descriptions cover all seven parameters, so the schema alone is informative. However, the description introduces an 'expression' that is absent from the schema and says nothing about which of ref/url/city/feed/host/json/path should be supplied, making parameter selection harder rather than easier.

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 claims a specific purpose, 'Evaluate a+b style arithmetic', but the input schema has no expression parameter; its seven string parameters are all unrelated shape checks and hints. This is misleading: an agent cannot tell that the tool cannot actually do arithmetic, and 'Expression discarded' undercuts the stated 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?

No when-to-use or when-not-to-use guidance is provided, and no alternative tools are mentioned. The agent is given no basis for choosing calc-eval over siblings such as validate-json, domain-shape, or weather-hint.

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

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

With no annotations present, the description carries the behavioral disclosure burden. 'Page content is not stored' is a useful privacy-related behavioral trait, but the description does not disclose network side effects, timeouts, error behavior, or any access requirements. It is minimally transparent but not comprehensive.

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

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

The description is two short sentences, front-loading the core purpose and adding one relevant safety note. There is no filler or redundant restatement of the tool name.

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 a seven-property schema, no output schema, and no annotations, yet the description covers only the URL case. It omits the role of the remaining parameters, the return shape, and error handling, 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?

The input schema already provides descriptions for all seven parameters, so the baseline is 3. The description only reinforces that 'url' is the primary input and adds no clarity about whether the other parameters are required, alternative modes, or intended decoys.

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 result—host, scheme, and HTTP status—for a URL, which is more than a tautology. However, the tool name 'citation' and the presence of six other unrelated schema parameters are not reconciled, and there is no differentiation from sibling URL/status tools like fetch-status or normalize-url.

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

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

The description gives no explicit when-to-use or when-not-to-use guidance, nor any comparison against alternatives. An agent must infer that this tool is appropriate whenever host/scheme/status for a URL is needed, and the noisy schema only increases the ambiguity.

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 supplies one concrete behavioral guarantee: identifiers are not retained. It omits whether the tool is read-only, whether any external calls occur, or what happens to the input beyond classification, 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?

Two short sentences with the purpose first and the privacy guarantee second; no filler words. It is appropriately brief, though the brevity overlaps with the ambiguity captured elsewhere.

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?

Seven heterogeneous parameters, no output schema, and no annotations demand more context than this. The description never explains what a classification result looks like, which parameter(s) to provide, or how this tool fits with the sibling tool set, so correct invocation remains uncertain.

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

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

The input schema already documents all seven parameters with individual descriptions, so schema coverage is high. The description adds no parameter-level meaning or relationship among ref, url, city, feed, host, json, and path, which is acceptable at baseline though not enhanced.

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 real purpose—show how the request is classified—so it is not a tautology or missing. However, the classification scheme, categories, and what makes this tool different from siblings like validate-json or normalize-url are left undefined, making the purpose vague.

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 when-to-use or when-not-to-use guidance and names no alternatives. It does not tell the agent how compatibility relates to any of the many sibling shape/validation tools, leaving selection 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 provided, and the description does not mention output format, error behavior, side effects, or whether the operation is purely syntactical beyond the 'without WHOIS' note. The agent is left to infer basic runtime behavior.

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

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

The description is a single concise sentence with no redundant wording. It front-loads the main action and adds a brief scope qualifier, though it could include a little more practical detail without becoming verbose.

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

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

With nine optional parameters, no output schema, and no annotations, the description is too sparse for an agent to confidently call the tool. It does not specify the input parameter, expected result shape, or failure conditions.

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

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

The schema descriptions cover all parameters, but the tool description does not explain how the nine optional parameters relate to the hostname-splitting operation. The presence of unrelated parameters such as city, zone, and json creates ambiguity about which input is actually used.

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

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

The description clearly states the core action: split a hostname into labels. The phrase 'without WHOIS or ownership data' also gives a useful negative scope, distinguishing it from ownership lookups. However, it does not explicitly say which parameter should contain the hostname.

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 sibling tools like normalize-url, browser-url-ok, or file-path-ok. The only hint is a negative statement about WHOIS/ownership data, which is not enough to direct an agent's 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?

With no annotations provided, the description carries the behavioral burden. It does disclose that the call is a HEAD request, is limited to public URLs, and returns only status, which is genuinely useful. It does not explain redirect/error behavior, rate limits, fallback behavior, or how the non-URL parameters behave, which matters given the broad schema.

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

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

The single sentence is clean, front-loaded with the key verb and outcome, and contains no filler. It is arguably too short for the seven-parameter schema, but what is present is well-structured and 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?

Given no annotations, no output schema, and a seven-parameter input schema spanning URLs, refs, cities, feeds, JSON, and paths, the one-sentence URL-only description is insufficient. An agent cannot determine what 'status' means for the other input types or what the tool returns in those cases.

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

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

The schema itself already documents all seven parameters in reasonable detail, so the baseline is 3 even without extra description coverage. The description adds nothing beyond the URL case and does not help an agent choose among the many heterogeneous 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 concrete action and result: HEAD a public URL and return status only. This is clear for the URL case and gives some differentiation from fully-fetching siblings, but the input schema exposes seven heterogeneous parameters (ref, city, feed, json, path, host) that the description does not address at all, so the stated purpose is incomplete.

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 'status only' implies a lightweight, header-level check and therefore gives some guidance about when to use it versus fetching full content. However, it never names any sibling tools or gives explicit when-to-use/when-not-to-use conditions, leaving an agent to infer the boundary.

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

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

With no annotations, the description carries the full burden, but it only discloses that the path is discarded. It does not explain whether the tool validates, fetches, normalizes, what happens with invalid URLs, or whether any network access occurs. Minimal behavioral insight.

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 key action is front-loaded, and 'Path discarded' is a compact behavioral note. Slightly cryptic, but there is no wasted words.

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

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

The tool has 9 parameters, no annotations, and no output schema, raising the need for description detail. This description does not specify the output, required parameter, invalid-input behavior, or how it differs from sibling URL tools, leaving a substantial 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?

Schema description coverage is 100%, so the baseline is 3. The description adds domain context ('Figma file URL') that helps select the relevant `url` parameter, but it does not explain which parameter to use or how the 9 unrelated parameters fit.

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 action ('Parse') and resource ('a Figma file URL'), so an agent can tell this is the tool for Figma URLs among the sibling shape/URL tools. However, it does not say what 'shape' means or what the tool returns, so the purpose is clear but not fully explicit.

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

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

No guidance is given about when to use this tool versus siblings like normalize-url, browser-url-ok, or github-repo-shape. The only implied context is the phrase 'Figma file URL', but there are no exclusions or alternatives 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds a useful concrete behavioral detail: 'No disk access.' This goes beyond the annotations by clarifying the check is purely lexical/shape-based, but it does not disclose what happens for an unsafe path, return values, or whether any normalization occurs.

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

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

The description is two short sentences with no filler: the first states the purpose and the second adds a critical behavioral constraint. It is front-loaded and 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 seven schema parameters, only one of which matches the described 'path' concept, the description is notably incomplete. It fails to clarify whether the other parameters are alternatives, optional, or irrelevant, and with no output schema it also leaves the expected return value unspecified.

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 provides descriptions for all seven parameters, including 'File path to check' for path, so schema coverage is high. The description does not add any parameter-level meaning beyond the schema, especially problematic because the schema includes many unrelated fields (ref, url, city, feed, host, json) that the description does not explain or reconcile with 'path.'

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

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

The description clearly states the tool checks whether a path looks safe, using a specific verb ('check') and resource ('path'). However, it does not explicitly distinguish itself from sibling shape-checkers such as browser-url-ok or domain-shape, and the broad term 'looks safe' leaves the exact validation scope slightly vague.

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 disk access' implies this is the right tool when a static, non-filesystem-touching path validation is needed, which gives some usage context. However, it does not explicitly state when to prefer this over alternatives, nor does it mention any exclusions or 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?

Annotations are empty, so the description carries behavioral weight. It identifies the external dependency (Open-Meteo) and the output schema adds lat/lon/source, but the description alone does not state whether this is a live network call or how unknown places are handled.

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

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

One sentence, no filler, and the key facts are front-loaded: output (latitude/longitude), scope (place), and source (Open-Meteo). It is compact to the point of slight under-specification, but it does not waste 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?

The output schema covers return values and the parameter descriptions are rich, so the sparse description is not fatal. The main gap is that the description never says which of the many schema properties is the correct input, leaving the agent to infer that 'city' is the one intended.

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 high because every parameter has its own explanation, so the baseline is 3. The tool description adds no parameter-level detail and, notably, never explicitly maps 'place' to the 'city' parameter, though that mapping is semantically inferable.

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 conveys a coordinate lookup for a place via Open-Meteo, which is specific enough to distinguish it from sibling tools like weather-hint or timezone. It lacks an explicit verb, but the meaning is clear and not a tautology of the tool name.

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

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

The phrase 'for a place via Open-Meteo' implies the intended use: when an agent needs latitude and longitude for a place name. It does not explicitly state when not to use it or which alternative tool to prefer, so the usage guidance is implied rather than explicit.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It states a pure parse operation, but does not mention the return shape, invalid URL handling, or that only the `url` parameter is likely relevant while several other schema parameters are explicitly discarded. The schema gives discard hints, but the tool-level behavior remains under-specified.

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

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

The description is a single, compact sentence with zero filler. The action and target are front-loaded, making it easy for an agent to quickly understand the primary 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?

There is no output schema, and the return values are only implied by the word 'parse' plus 'owner and repo'. The schema contains several unrelated parameters with discard notes, which adds ambiguity about required inputs. The description does not handle invalid URLs, normalization behavior, or the exact result structure, so it is not complete enough 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?

All 7 input schema parameters have descriptions, so schema coverage is 100% and the baseline is 3. The tool description adds one useful nuance: `url` is intended to be a GitHub URL for owner/repo extraction, which is clearer than the schema's generic 'normalize or cite'. However, it does not clarify output parameter names or how the other parameters relate to the parse.

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

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

The description uses a specific verb, 'Parse', with a clear object, 'owner and repo', and a resource, 'GitHub URL'. This clearly identifies the tool's core function and distinguishes it from sibling shape/validation tools like jira-key-shape or domain-shape, though it does not explicitly contrast any sibling.

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 mention of when to use this tool, when not to use it, or which alternative to choose. The agent must infer usage from the name and one-line description, with no exclusions or routing 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. It does communicate the key behavior (counting current HN front-page stories) and a limitation ('Titles discarded'), but it does not explain what happens with the many optional parameters, whether a network request is made, or what the output looks like.

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

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

The description is exceptionally short and front-loaded with the main action. Both sentences earn their place, with no tautology or redundant 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?

The tool has 9 optional parameters, no output schema, and no annotations, yet the description does not explain how to invoke it correctly or what result format to expect. The phrase 'Titles discarded' is helpful but leaves too much unspecified for a modern agent to reliably use this tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning beyond what the schema already provides, and it does not clarify which parameter, if any, is relevant to the HN front-page 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 states a specific verb and resource: 'Count current Hacker News front-page stories.' This clearly distinguishes the tool from sibling counting tools such as memory-key-count and search-query-len, and the added 'Titles discarded' clarifies that story titles are not returned.

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

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

The description gives no guidance on when to choose this tool over alternatives such as web-fetch or search-query-len, and it provides no exclusions or prerequisites. The only implied context is the purpose itself.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not say whether the tool returns a static list, whether it filters based on input, whether parameters affect output, or what the response format looks like. The description fails to disclose any behavioral traits.

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 contains no filler, but it is a sentence fragment rather than a structured instruction. It front-loads the core noun phrase but lacks a verb and any context, making it under-specified rather than appropriately 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 9 parameters and no output schema, so complexity is substantial. A one-phrase description is completely inadequate; it omits return values, invocation semantics, parameter effects, and relationship to sibling clock/time tools. This is insufficient for an agent to call the tool correctly.

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

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

Input schema coverage is 100%, and each parameter description states it is 'discarded' after a check or call, which is useful information about parameter irrelevance. The tool description itself adds no meaning beyond the schema, but the baseline of 3 applies due to 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 is a noun phrase, not a verb+resource statement. 'Common IANA timezone names for clock calls' implies the tool returns or provides a list of timezone names, but never states the action explicitly. It also doesn't differentiate from siblings like 'timezone' or 'utc-time' beyond the obvious naming.

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

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

There is no guidance about when to use this tool versus alternatives such as 'timezone' or 'utc-time'. The description gives no context about integration, prerequisites, or conditions that would select this tool over related ones.

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 disclosure burden. It does add one meaningful behavioral trait — output is truncated to group counts rather than full contents and only public robots.txt files are fetched. However, it says nothing about failure modes, redirects, blocking/rate limits, or what 'groups' means semantically.

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?

Eleven words in a single sentence with zero waste. The action is front-loaded and the output constraint follows immediately, giving the agent the essential information in the first read.

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 7 heterogeneous parameters, no annotations, and no output schema, one sentence is insufficient. The description never maps the purpose onto the input schema (which parameter receives the site URL?), explains 'group counts', or covers error handling. An agent must guess 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?

Schema coverage is 100% (all 7 params have descriptions), so the baseline is 3. The description adds only the qualifier that the target is a public robots.txt, which implies the URL parameter is the driver, but it does not disambiguate among the heterogeneous schema params (city, feed, json, path), several of which appear unrelated to robots.txt fetching.

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 ('Fetch a public robots.txt') plus an explicit output contract ('return group counts only'). This distinguishes it from generic siblings like web-fetch or fetch-status, which retrieve raw content, by narrowing both the target resource and the response shape.

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

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

No when-to-use guidance or alternatives are mentioned. The intended use is only implied by the purpose statement, and the description does not explain when an agent should pick this over web-fetch, fetch-status, or normalize-url, nor does it state 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?

With no annotations present, the description must carry the transparency burden. It discloses one useful behavior—'Key discarded' signals no retention—but does not state the return format, side effects, or whether the check is local/non-mutating. Partial disclosure, not a complete behavioral profile.

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

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

Two short sentences with the core purpose first and the retention behavior second; zero filler. 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 seven parameters, a one-line purpose, and no output schema. An agent cannot determine what to pass for a Jira key or what the check will return, so the definition leaves critical call-construction details unresolved.

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 each parameter syntactically, so the baseline is 3, but the tool description never connects any parameter to the Jira issue key. Seven unrelated-looking properties (ref, url, city, feed, host, json, path) exist, and none is explicitly designated as the key input. The description adds no mapping, effectively compensating poorly for the schema's mismatch with 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 names a specific verb ('Check') and resource ('Jira issue key shape'), clearly distinguishing it from shape-checking siblings like github-repo-shape or domain-shape. However, it does not identify which input parameter carries the key, leaving a small but real 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?

No when-to-use or when-not-to-use guidance is given, and no alternative tools are referenced. Usage can only be inferred from the name and first sentence; there is no mention of prerequisites or comparison to siblings.

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

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

With no annotations, the description must disclose behavioral traits. It does reveal that the body is discarded, which is a useful behavioral detail, but it omits other important aspects like request method, redirect handling, or error behavior. The description adds some transparency but not enough for a fully informed call.

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

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

The description is a single, efficient sentence with no wasted words. The primary purpose (HTTP status) is front-loaded, and the discard behavior is a useful secondary note. However, given the tool has 9 parameters and no output schema, the description is arguably too terse to be fully useful, but as a concise statement it is well-formed.

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, many of which (e.g., city, feed, json, zone) seem unrelated to a 'library docs URL'. The description does not explain how these parameters relate to the tool's purpose, nor does it specify the output format or error handling. The absence of an output schema and the confusing parameter set leave significant gaps in what an agent needs to know to call the tool correctly.

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

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

Schema description coverage is 100%, so each parameter is documented in the schema. The tool description adds no parameter-specific meaning; it only describes the overall purpose. According to the calibration, a baseline of 3 is appropriate when the schema covers all parameters, even if the description adds nothing.

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 (returns HTTP status) and a specific resource (public library docs URL), and explicitly mentions that the body is discarded. It distinguishes the tool as a lightweight status check, but it does not differentiate it from sibling tools like fetch-status or web-fetch, leaving the agent to infer the unique value.

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 alternatives. The description does not mention exclusions, prerequisites, or situations where a sibling (e.g., fetch-status, browser-url-ok) would be more appropriate. The agent is left without routing information.

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

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

With no annotations, the description carries the full burden. It does disclose that 'Values discarded' and several parameter descriptions repeat discard behavior, which signals no persistence. But it fails to disclose the output shape, key-count semantics (top-level vs nested), error behavior, or side effects, so an agent cannot predict the call's outcome.

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

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

The two-sentence description is short, front-loaded, and free of filler; the first sentence states the action and the second adds behavioral information. It is slightly under-specified for such a large schema, but that is more a completeness issue than a conciseness issue.

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 required fields, no annotations, and no output schema, two sentences are insufficient. The description does not identify which parameter provides the object, what is returned, how to handle malformed JSON, or what happens when multiple or none of the parameters are supplied.

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 adds no parameter meaning and actively conflicts with the schema: it refers to a 'JSON object' while the only JSON parameter is a string 'to validate'. It never explains how the nine optional parameters relate to the count operation.

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

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

The description states a specific operation ('Count keys') and resource ('a JSON object'), which distinguishes it at a high level from validate-json. However, the input schema contains no parameter named or shaped as a JSON object; the closest candidate, 'json', is described as 'JSON text to validate', so an agent cannot map the stated purpose to the actual call.

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

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

No guidance is given about when to use this tool versus siblings such as validate-json, search-query-len, or the various shape-check tools. The description neither states when it is appropriate nor excludes alternatives, leaving the 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 present, the description discloses the key transformation behavior—query and fragment are dropped—and states what is returned. However, it does not clarify whether network access or auth is involved, nor does it explain how the many other schema parameters relate to the normalization behavior, leaving transparency 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 short sentences with no filler: the main function is front-loaded, followed by a useful caveat about query and fragment handling. Every sentence earns its place.

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

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

The core behavior is clear enough for basic invocation, and the schema's inline descriptions mitigate confusion from the seven parameters by explaining that many are discarded. Still, the lack of required markers, any output schema, or an explicit statement that only `url` is used makes the description only minimally complete for correct invocation.

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

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

All seven parameters already have descriptive text in the input schema, so schema coverage is high; the description adds only the URL-specific normalization behavior and does not need to repeat parameter meanings. It does not, however, help the agent identify which parameter is required or whether the extra parameters should be ignored.

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

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

The description states a specific verb and resource: it returns origin, host, and path for a URL, and clearly notes that query and fragment are dropped. This distinguishes it from sibling fetch/check tools in substance, though it does not explicitly name a sibling alternative.

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

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

No guidance is provided about when to use this tool instead of related URL tools such as browser-url-ok, domain-shape, or web-fetch, and no conditions or exclusions are stated. The intended context is only implied by the mention of URL component extraction.

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 disclose one useful behavior: no browser is launched. But it does not clarify whether the check makes a network request, whether it has side effects, how errors are reported, or what the response looks like.

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

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

The description is two short sentences with no wasted words. The main purpose is front-loaded, and the second sentence adds a meaningful caveat. This is appropriately concise and well structured.

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

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

Given nine optional parameters, no output schema, no annotations, and overlapping sibling tools, the description is incomplete. It does not say which parameter to use, what the return value is, what 'opened' means, or why the unrelated-looking parameters exist. An agent could guess, but the description alone is not sufficient to invoke the tool with confidence.

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 100% description coverage for all nine string parameters, so the baseline is 3. The tool description adds no parameter-level meaning. The schema's 'url' description says 'HTTPS URL to normalize or cite,' which does not align cleanly with the stated purpose of checking whether a URL can be opened, and the other parameters (city, feed, json, path, query, timezone) are left unexplained relative to the tool's purpose.

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

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

The description clearly states a specific action and resource: 'Check whether a URL can be opened.' The additional sentence 'No browser is launched' adds a useful distinguishing trait, especially given the tool name includes 'playwright.' However, it does not define what 'can be opened' means exactly (HTTP reachability, URL validity, renderability) and does not name a sibling 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 description gives no explicit guidance about when to use this tool versus alternatives such as browser-url-ok, fetch-status, or web-fetch. Saying 'No browser is launched' is a behavioral caveat, not a usage condition. There is no 'use this when...' or 'instead use...' guidance.

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

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

The phrase 'Query discarded' discloses that the input is not retained after the call, and the query parameter description repeats 'discarded after the length check.' However, the description does not explain the return value, side effects, or what happens if the query is absent, leaving significant behavioral details unspecified.

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 terse and front-loads the main purpose in the first sentence. The second sentence is a fragment but contributes a transparency note; no redundant wording is present.

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 is incomplete: it never states the result format (e.g., an integer character count) and never explains the unusual list of optional parameters. It leaves the agent to guess the behavior when query is omitted or when other params are supplied.

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 carry most of the semantic weight; the query parameter is described as 'Search text; discarded after the length check.' The main description adds the notion of counting characters, but does not clarify why the other eight parameters exist or whether they are ignored, limiting added value.

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

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

The description clearly states the core action: 'Count characters in a search query.' It names the resource (a search query) and the operation (counting characters), which is enough to distinguish it from most sibling tools. The following 'Query discarded' adds a small ambiguity but does not obscure 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?

No usage guidance is provided. The description never says when to use this tool instead of alternatives like memory-key-count or other shape/count tools, and it does not mention prerequisites or typical call patterns.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not say whether the tool is read-only, what it returns, how it handles inputs (despite schema notes that several are discarded), or whether there are side effects. Behavior is completely opaque.

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, but it is under-specified rather than concise. A single noun phrase provides no actionable content and does not earn its place as the tool definition.

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

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

For a tool with seven mostly unrelated parameters and no output schema, one vague sentence is entirely inadequate. The agent cannot determine which parameter to provide, what the tool will do with it, or what response 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?

All seven parameters have individual schema descriptions, so schema coverage is high and the baseline is 3. The tool description adds no meaning about how these parameters relate to the status-code catalog or which parameter should be supplied.

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

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

The description is a noun phrase that essentially restates the tool name: 'Short catalog of common HTTP status codes.' It lacks an action verb, does not state what invoking the tool produces, and does not distinguish it from sibling tools such as 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 about when to use this tool, what inputs are appropriate, or how it compares to alternatives. With many sibling tools covering similar domains, an agent receives no routing information.

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

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

The description discloses one behavioral trait: 'Prompt discarded.' The input schema elaborates that each parameter is discarded after a shape check. However, without annotations, the description carries the full burden and leaves out important behavioral details such as side effects, output format, and the fact that all parameters are effectively ignored. It is partially transparent 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?

The description is exactly two sentences, both earning their place: the first states the core purpose, the second states a critical behavioral trait. There is no redundancy or unnecessary detail, making it highly concise and front-loaded.

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

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

Despite a complex schema with eight optional parameters and no output schema, the description does not clarify why an agent should pass any parameters, whether any are required, or what the returned template looks like. This leaves the agent without enough context to invoke the tool in a meaningful or correct manner.

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 provides full descriptions for every parameter, including the fact that they are discarded after a shape check (e.g., 'Git ref name; discarded after the shape check'). The description adds no additional parameter-level meaning, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Return a three-step thinking template.' This clearly distinguishes it from sibling tools like validate-json, normalize-url, and weather-hint, which perform concrete checks or lookups. It does not, however, specify what the template contains or why it might be used, so it stops short of a perfect 5.

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

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

No guidance is given for when to use this tool versus alternatives. The description does not mention scenarios in which a thinking template is helpful, nor does it reference any sibling tools or exclusions. The only implicit hint is the word 'thinking', which is too vague to qualify as clear context.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure. It only says "Current time in a named IANA timezone," giving no information about output format, validation behavior, network access, or side effects. The schema's parameter notes like "discarded" and "no side effects" do not cover the tool's overall behavior.

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

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

The description is extremely concise and front-loaded, with no filler words. Every word contributes to stating the tool's 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?

The description is far too incomplete for a tool with seven parameters and no output schema. It fails to identify the required timezone input, explain what the tool returns, or reconcile the obvious mismatch between the description and the input schema. An agent cannot confidently call 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?

Although all seven parameters have individual schema descriptions, none of them represents a timezone name. The description does not map "named IANA timezone" to any parameter, so an agent cannot determine which field to populate. The schema coverage is high but irrelevant to the tool's stated purpose, and the description adds no parameter-level guidance.

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 purpose: returning the current time for a named IANA timezone. It also distinguishes itself from siblings like utc-time and iana-zones by emphasizing "named IANA timezone." However, it lacks an explicit verb and the purpose is undermined by the input schema showing no timezone parameter.

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

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

There is no guidance about when to use this tool versus alternatives such as utc-time or iana-zones. The phrase "named IANA timezone" implies a use case, but no conditions, exclusions, or alternative routing are provided.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the output but does not disclose whether the timestamp is ISO-8601, Unix epoch, or another format. It also fails to clarify that the many optional schema parameters are irrelevant or ignored, leaving the agent uncertain about whether passing a 'zone' or 'url' affects the result.

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 front-loaded: 'Current UTC timestamp.' There is no fluff or redundancy. It could be slightly more structured with an explicit verb, but for a zero-required-parameter tool, the brevity is mostly appropriate.

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

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

The description is incomplete for the given context. There is no output schema and no annotations, so the agent must infer the return format and behavior from a three-word phrase. It also does not explain why nine optional parameters exist, whether they are all accepted but ignored, or whether any of them influence the output. For a tool with this many parameters, more context is needed.

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 meaning beyond the schema, but the schema already documents each parameter individually. All parameters are optional, and the description's simplicity implies none are required, so no additional parameter semantics are critical.

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

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

The description clearly identifies the tool's purpose: returning the current UTC timestamp. It is succinct and differentiates itself from sibling tools like timezone and iana-zones by specifically stating 'UTC'. It lacks an explicit verb like 'returns', but the meaning 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 provides no guidance on when to use this tool versus alternatives. It does not mention that no arguments are needed, nor does it distinguish itself from the related 'timezone' sibling. An agent receives no help in choosing between utc-time and timezone for a given request.

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 burden of behavioral disclosure. It explicitly says 'The body is discarded,' which signals a non-persisting validation operation. However, it does not describe the result format, whether validation is syntax-only, or how errors are reported.

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 primary function is front-loaded, and the discard side effect is the only additional 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 is simple and the schema is well-documented, but the description omits the return value or success/failure indication and does not fully clarify which parameter is the 'body.' These are clear gaps for a tool with no output schema.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters and their meanings. The description adds no parameter-level detail beyond referring to a 'body,' but the schema's 'json' parameter fills that gap.

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 target: 'Check whether a body is valid JSON.' This directly matches the tool name and distinguishes it from sibling tools that check URLs, file paths, or domain shapes.

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 instead of sibling validation tools such as domain-shape or browser-url-ok. The only implied usage signal is the tool name itself; there are no explicit conditions or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavior disclosure, but it only says 'Current temperature for a city via Open-Meteo.' It does not describe whether this is a read-only external call, what units the temperature is returned in, how the city name is resolved, or how the other schema inputs like ref, url, and feed are treated.

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 or redundancy. It is concise and to the point, though slightly under-specified for a tool with seven parameters and no other documentation.

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

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

For a tool with seven schema parameters, no annotations, no output schema, and a narrow purpose, the description is incomplete. It omits required parameters, the exact output format or units, error behavior, and how the unrelated-looking parameters such as ref, url, feed, and host should be handled.

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

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

The input schema already describes all seven parameters, and the description adds only that the city parameter is the operative one and that the data source is Open-Meteo. It does not clarify how the remaining parameters relate to the tool or how they should be populated, so it provides little value 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 clearly states that the tool returns the current temperature for a city and identifies the data source as Open-Meteo. Although it lacks an explicit verb like 'Gets' or 'Returns', the phrasing is specific enough to distinguish it from sibling tools such as geo-hint or web-fetch.

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

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

There is no guidance on when to use weather-hint versus alternatives like geo-hint or web-fetch, and no mention of conditions, exclusions, or prerequisites. The description only states the general function without helping an agent decide when to invoke it.

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

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

With no annotations, the description carries the behavioral burden, and it does usefully disclose that only status/content type are returned and the body is discarded. However, it does not explain that non-URL parameters appear to be ignored, nor does it address network behavior such as redirects, timeouts, auth, or failure handling.

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 key constraint 'Body discarded' is stated immediately. It is slightly under-specified for a tool with a confusing nine-parameter schema, but that issue is better captured by completeness rather than 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?

For a tool with no annotations, no output schema, and a schema containing nine optional parameters, this sparse description is incomplete. It does not identify which parameter is required in practice, what happens when other parameters are passed, or how the tool relates to sibling fetch and status-checking tools.

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

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

Schema description coverage is 100%, so each parameter already has an individual description and the baseline is 3. The tool description adds little beyond implying that `url` is the meaningful parameter, and it does not rationalize why the schema includes eight unrelated optional 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 specifies a narrow operation: return HTTP status and content type for a public URL, discarding the body. It is easy to understand on its own, but it does not distinguish this tool from siblings like fetch-status, browser-url-ok, or normalize-url.

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

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

The description gives almost no guidance about when to choose this tool over alternatives like fetch-status or browser-url-ok. It also fails to clarify which of the nine optional schema parameters should actually be supplied, especially when most are unrelated to URL fetching.

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

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

No annotations are provided, so the description must carry the burden. It does disclose that the title is discarded after the call, implying no retention. However, it does not reveal network behavior, error handling, return values, or whether the check is local or remote.

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

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

The description is short, front-loaded, and free of filler. The second sentence adds one useful behavioral detail. It is not a 5 because the brevity leaves critical invocation information unstated.

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 annotations, and no output schema, the description is severely incomplete. The schema provides per-parameter descriptions, but they do not align with the advertised Wikipedia-title check, so the agent still cannot confidently select inputs or understand expected 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?

Even though schema coverage is 100%, none of the nine parameters is described as the Wikipedia title. The closest candidate, 'query', is documented as 'Search text; discarded after the length check,' which does not match the advertised purpose. The description mentions 'Title' but never maps it to a schema property, making invocation unreliable.

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 specific verb and resource: 'Check whether a Wikipedia title exists.' This clearly identifies the tool's core operation. It is less than a 5 because it does not explicitly differentiate itself from related siblings like citation or normalize-url.

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

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

The description provides no guidance on when to use this tool versus alternatives. With 27 sibling tools, there is no mention of conditions, exclusions, or a preferred alternative.

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