Asia/Kuala_Lumpur clock

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

There are no annotations, so the description carries the behavioral burden. It discloses the returned content categories and, importantly, states that 'Task text discarded,' which is privacy-relevant and not visible from the schema. It does not mention auth, rate limits, or network side effects, but for a lookup-style tool this is reasonably transparent.

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, each earning its place: the purpose, the returned artifacts, and the data-handling caveat. It is front-loaded and avoids duplicating schema 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 description covers what the tool returns and its data-handling behavior, while the schema covers parameter semantics. It is missing a short explanation of what 'Monid' is and which of the six input fields a typical request should populate, but it is still usable for tool selection and 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 seven parameters. The description adds no parameter-level detail beyond the note that task text is discarded, so it does not meaningfully extend what an agent can already read from the 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 states a specific action and object: 'Find a public pay-per-call tool gateway (Monid)' and lists the returned artifacts. This is distinct from the sibling check/hint tools, though the term 'Monid' is left unexplained and no sibling differentiation is 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?

The intended use is implied: call this when you need the Monid gateway's CLI setup, how-it-works, skill file, or remote MCP hops. However, there are no explicit when-not instructions or alternative routing cues, so the agent must infer when this tool is preferable to siblings like web-fetch or normalize-url.

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

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

The description discloses one meaningful behavioral trait—'No browser is launched'—which is useful context and signals a non-destructive, non-browser operation. Yet with no annotations available, the description carries the full burden and does not disclose what the check actually does (network request? URL shape? side-effect-free?) or what the result means.

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, and the most important behavior is front-loaded in the first sentence. It could still say a bit more about return semantics, but every sentence present 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?

With no annotations, no output schema, and an unexpectedly broad schema with eight parameters including several 'discarded' ones, this description is insufficient. It never states what the tool returns, what 'can be opened' means, or which parameters matter, leaving an agent to guess on a relatively complex 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?

The input schema already documents all eight properties with descriptions, so the baseline is 3. The description itself adds no parameter-level detail and does not clarify that `url` appears central while several other fields are marked as 'discarded'; those details live only in the schema.

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

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

The description uses a clear verb and resource: 'Check whether a URL can be opened.', and the second sentence 'No browser is launched.' separates this from browser-based tools like playwright-url-ok. However, 'can be opened' is left vague—it does not say whether this is a network reachability check, a URL format check, or something else.

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 sentence 'No browser is launched.' implies this is a lightweight alternative to browser-launching checks, giving some context about when to use it. But the description does not name sibling tools, state explicit exclusions, or explain when to prefer playwright-url-ok or fetch-status instead.

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

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

With no annotations and a self-contradictory description, the tool's behavior is not transparent; 'Expression discarded' conflicts with 'Evaluate ... arithmetic' and the schema parameters are described as discarded.

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

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

The description is short but wastes words on a contradictory note ('Expression discarded') and omits critical invocation details for the intended arithmetic operation.

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 highly incomplete for a 9-parameter, no-output-schema tool; it lacks an expression parameter, return format, and any usage context, leaving an agent unable to use it correctly.

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

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

None of the nine parameters (ref, url, city, feed, host, json, path, zone, query) relate to arithmetic evaluation, and their descriptions indicate they are discarded, which adds no meaningful semantics for calc-eval.

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

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

The description states 'Evaluate a+b style arithmetic' but immediately says 'Expression discarded' and the input schema contains no expression parameter, making the actual purpose contradictory and unclear.

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

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

No guidance is provided on when to use calc-eval versus sibling tools, and the description does not explain how to supply an arithmetic expression.

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 behavioral burden. It adds the useful privacy context that page content is not stored, but it does not disclose other behaviors such as network access, response format, or the fact that several schema parameters are discarded during the check.

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

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

The two-sentence description is front-loaded and free of filler; the core result and the privacy note each earn their place. It could be considered slightly undersized given the seven-parameter schema, but as pure conciseness it is strong.

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 seven parameters, the description is incomplete. It does not explain the return format, the role or disposal of the non-URL parameters, or how this tool compares with sibling tools, leaving an agent to infer important invocation details.

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

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

The input schema already describes all seven parameters with individual meanings, so high schema coverage sets the baseline at 3. The description adds no parameter-level detail beyond the notion that a URL is the relevant input.

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 output for a URL (host, scheme, HTTP status) and adds a distinguishing privacy note that content is not stored. It is clear about the core action, but it does not explicitly differentiate itself from siblings like normalize-url 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?

The intended use is implied: call when host, scheme, or HTTP status for a URL is needed. There are no explicit when-not-to-use conditions or references to alternative sibling tools, so usage guidance is basic 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?

The description offers a privacy note ('No identifiers are retained') but does not explain side effects, return values, error behavior, or whether inputs are consumed. With no annotations, this leaves significant behavioral ambiguity.

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

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

The description is extremely short and front-loaded, with no redundant phrasing. It loses some points only because the brevity omits necessary operational context.

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

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

With nine heterogeneous parameters, no output schema, and no annotations, the description is not complete enough for an agent to know what outcome to expect or how the parameters are used. The classification result is entirely 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 covers all parameters with per-parameter descriptions, meeting the high-coverage baseline. However, the main description adds no unifying explanation of how the nine unrelated parameters relate to 'classification' or 'compatibility'.

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 how this request is classified') but does not specify what kind of classification is produced or how 'compatibility' relates to the action. It is too vague to distinguish from other analysis/validation tools in the sibling list.

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

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

No guidance is provided about when to use this tool versus the many sibling tools, nor what input conditions are appropriate. An agent cannot determine which scenario should invoke 'compatibility' rather than, for example, 'validate-json' or 'normalize-url'.

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

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

With no annotations provided, the description must carry the full behavioral disclosure burden. It only states the core splitting action and what it does not include; it doesn't mention that most inputs are discarded, whether validation errors occur, or what the result contains. The schema hints at discard behavior, but the tool description itself adds minimal 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 clear sentence with no wasted words, front-loading the action and scope. Given the tool's multiple parameters and discard behavior, the extreme brevity comes at the cost of missing useful context, but it is concise and 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?

With 8 parameters (many marked discarded), no output schema, and no annotations, the description is far too thin. It doesn't explain the meaning of 'shape', what the split returns, how to identify the correct parameter, or how discarded fields are handled. An agent would be under-informed when invoking 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?

All 8 parameters already have schema descriptions, so the baseline is 3. The tool description implies that 'host' is the relevant parameter, but the schema already calls it 'Public hostname'. No parameter-specific meaning is added 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 the specific action: split a hostname into labels, and explicitly excludes WHOIS or ownership data. This distinguishes it from sibling shape tools, though it doesn't name an alternative or describe the output format.

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 vs. siblings like github-repo-shape or jira-key-shape. The negative clause implies it cannot answer ownership questions, but it never says which tool would be appropriate for that need.

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 is the only behavioral source since no annotations exist. It does disclose the HTTP method and the output scope ('status only'), which is genuinely useful. However, it does not describe your handling, failure modes, or whether the tool follows redirects, leaving important behavior 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 a single concise sentence with no filler. The key constraints, HEAD and status-only, are front-loaded and easy to parse.

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

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

Given seven parameters, no annotations, and no output schema, this description is too sparse. It does not say which parameter is required, what the returned status looks like, or what happens on invalid input or network failure. The many 'discarded' fields in the schema further complicate the picture without the description explaining how they relate.

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 schema descriptions, so the schema carries most of the burden. The description adds only the qualifier that the URL must be public, which is helpful but does not resolve the odd 'normalize or cite' wording on the `url` parameter or clarify how the other discarded fields relate to the HEAD request.

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 uses a specific method (HEAD), a concrete resource (public URL), and a clear result ('status only'), so the tool's core purpose is unmistakable. It does not explicitly distinguish itself from siblings such as web-fetch or browser-url-ok, so it falls just short of a 5.

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

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

No guidance is given about when to use fetch-status versus the many sibling tools. The phrase 'status only' implies a lightweight health-check use case, but there is no explicit exclusion of alternatives or mention of scenarios where a full fetch would be needed.

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 only says 'Path discarded.' It fails to disclose whether the tool performs network access, what it returns, or how it handles invalid or real Figma URLs.

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?

Six words are front-loaded but underspecified rather than appropriately concise for a tool with nine optional parameters. 'Path discarded' is ambiguous—whether URL path or the 'path' parameter—and the entry lacks usable structure.

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?

No output schema, no annotations, and no required parameters; the description does not tell an agent what to pass, what success looks like, or what result is produced. This is insufficient 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 the baseline is 3. The description adds no parameter-level meaning and does not indicate which of the nine optional fields is relevant, but the schema already documents each parameter.

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

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

States a specific action and resource: 'Parse a Figma file URL.' The mention of Figma differentiates it from sibling URL/shape tools such as domain-shape or normalize-url. The phrase 'Path discarded' adds a shred of scope but leaves the extraction target unclear.

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

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

No guidance on when to use this tool over sibling URL/shape tools, no exclusions, and no indication which input (likely url) should be provided. Usage is only implied by the tool name and the verb 'parse'.

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. It does disclose a key behavior: no disk access, which tells an agent this is a safe, non-mutating validation. However, it does not explain what 'looks safe' means, what the tool returns, or whether it can error on unexpected 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?

The description is two short clauses: an action statement and a key constraint. It is front-loaded, contains no filler, 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?

With no output schema and no annotations, the description leaves out important information for correct invocation: what a 'safe' path means, what the return value looks like, and how to interpret the many unrelated schema properties. An agent given only this description would be uncertain about how to call the tool correctly beyond passing `path`.

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, with every parameter having a description, so the baseline is 3. The tool description adds no parameter-level meaning beyond reinforcing the `path` param. The presence of many unrelated params (`ref`, `url`, `city`, `feed`, `host`, `json`) is confusing and the description does nothing to clarify which parameter is actually relevant.

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

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

The description states a specific verb ('check'), resource ('a path'), and criterion ('looks safe'), and adds 'No disk access' to distinguish it from filesystem-touching tools. It is clear and immediately recognizable, though 'safe' is somewhat vague and could mean traversal safety, syntax validity, or access permissions.

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

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

The description offers no guidance on when to use this tool instead of siblings like `normalize-url`, `wiki-title-ok`, or `browser-url-ok`. 'No disk access' implies use for safe, side-effect-free validation, but no explicit when/when-not conditions or alternative routes 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 all annotations null, the description must carry the full behavioral burden. It only hints at an external network call via Open-Meteo, but says nothing about whether the operation is read-only, has side effects, or what happens on failure. The schema note that city is 'discarded after the call' is buried and not reflected in 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, direct sentence with no fluff. It is appropriately concise, but the conciseness costs essential usage and parameter information that could have been added without making it 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?

There is no output schema and no annotations, so the description must supply both input and output expectations. It provides the output (latitude/longitude) but not how to specify the place, and it doesn't clarify why the schema lists many unrelated fields. An agent cannot confidently construct a valid call from this definition alone.

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

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

The description mentions 'a place' but never maps that to an actual input property. The schema only complicates matters: the city field is described as a 'public weather hint', which does not match the geo-coordinate purpose. High schema coverage cannot compensate because the field semantics appear misaligned with this tool.

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

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

The description clearly identifies the tool's function: returning latitude and longitude for a place via Open-Meteo. It has a specific verb and resource, and is distinct from siblings like weather-hint and timezone. It loses the top mark because it does not explicitly distinguish itself from any named 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?

There is no guidance on when to use this tool versus alternatives, nor any mention of preconditions or exclusions. The single sentence states what it does, but not when or why an agent should select it over other hint tools.

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

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

With no annotations present, the description carries the behavioral burden. It clearly frames the operation as a parse, implying a non-destructive, non-mutating pure function. It does not describe error behavior or explicitly state that other input fields are ignored, but the schema already documents that each extra field is discarded.

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

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

The description is a single short sentence with no filler and the key verb and object are front-loaded. Every word contributes to the agent's understanding.

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

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

For a simple pure parser, the combination of description and schema is nearly complete: the description identifies the GitHub-specific target and the schema explains what happens to each parameter. There is no explicit return-shape statement, but 'owner and repo' strongly implies the output fields, and no output schema is provided to fill that 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?

All seven parameters have descriptions in the schema, so the baseline is 3. The description adds modest value by linking the `url` parameter to GitHub repository URLs, but it does not explain the role of the other fields; the schema already covers their discarded-after-check behavior.

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

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

The description states a specific verb ('Parse'), a specific output ('owner and repo'), and a specific source ('a GitHub URL'). It clearly distinguishes this from sibling shape tools like domain-shape or jira-key-shape, and it goes beyond simply restating 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 intended use case is implied: use this tool when you have a GitHub URL and need owner and repo. However, there is no explicit when-to-use, when-not-to-use, or mention of alternatives, so the agent must infer the routing from the purpose.

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

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

The description mentions counting stories and discarding titles, but it does not disclose that the nine input parameters appear to be ignored or irrelevant, nor does it explain side effects, output shape, or failure behavior. With no annotations provided, this leaves important behavioral uncertainty.

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

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

The description is extremely concise, front-loads the core action, and contains no filler or redundant wording.

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 such a broad and unrelated optional parameter set, the description is incomplete. It does not clarify whether arguments are accepted, ignored, or rejected, and it does not describe return format, error conditions, or network behavior. Additional context is needed for an agent to use 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?

Although the input schema has descriptions for all parameters, the tool description itself adds no parameter meaning. More importantly, several schema parameters (ref, url, city, feed, host, json, path, zone, query) seem unrelated to counting HN front-page stories, and their descriptions suggest other tools' behaviors, creating confusion rather than clarity.

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 verb ('Count'), resource ('current Hacker News front-page stories'), and result scope ('Titles discarded'). It is specific enough to distinguish this from sibling tools like web-fetch 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?

The description gives no guidance about when to use this tool instead of alternatives, nor does it explain when not to use it. There is no explicit context about prerequisites or selection criteria relative to the sibling tools.

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

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

No annotations are present, and the description does not disclose side effects, read-only behavior, or the fact that most schema parameters are discarded. The schema's per-parameter notes are not summarized at tool level.

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 redundant detail. It is front-loaded with the key term 'IANA timezone 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 description does not state whether a call needs no arguments, what the output format is, or how to verify a zone name. With a misleading broad schema and no output schema, this is insufficient for correct use.

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 tool-level description does not explain how any of the nine optional parameters relate to retrieving common timezone names. Most parameter descriptions are irrelevant to timezones (e.g., 'Git ref name', 'JSON text to validate'), leaving agents confused.

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

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

The description identifies the tool's resource—common IANA timezone names for clock calls—and aligns with the tool name. It does not use an action verb but is still clear enough to convey what is provided.

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?

It gives only the vague context 'for clock calls' and does not state when to choose this tool over siblings like timezone or utc-time. There is no guidance on invocation or filtering.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It discloses read-only intent and an aggregated output shape ('group counts only'), but it omits error behavior, redirect or user-agent policy, and what 'counts' actually represent. This is a thin behavioral profile for a tool with no annotation safety hints.

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 sentence with no filler, and the key scoping phrase 'group counts only' is front-loaded. Every word earns its place without being 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 seven schema parameters, no output schema, and no annotations, the description is too sparse to be complete. It fails to connect the robots.txt behavior to the relevant input fields and gives no fallback behavior if a robots.txt is missing. An agent would need additional inference to call it correctly.

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

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

The input schema documents all seven properties with descriptions, so the schema-coverage baseline applies. The description adds no parameter-level mapping and never says which of host/url/path is actually used to fetch robots.txt, but the schema already provides per-parameter text, keeping this at baseline.

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

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

The description names a specific verb ('Fetch') and resource ('public robots.txt'), and the phrase 'group counts only' narrows the expected output clearly. It does not name or distinguish any sibling tool, so an agent cannot tell it apart from web-fetch or fetch-status on wording alone.

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 web-fetch, fetch-status, or domain-shape. No prerequisites or conditions are stated, such as needing a host or URL from a previous step, so an agent has to infer the tool's trigger context.

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

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

The phrase 'Key discarded' is the only behavioral hint, suggesting no persistence, but the description does not disclose whether it returns a boolean, a normalized key, an error, or anything else. With no annotations, the behavioral contract is largely 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 free of fluff: two short sentences with the primary action front-loaded. It could use more substance, but as far as conciseness and structure, it is appropriately sized.

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 incomplete in context: no output schema is provided, no return behavior is described, and the input parameters do not align with the stated purpose. An agent cannot reliably call this tool based solely on the description and 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 schema has nine generic string parameters—ref, url, city, feed, host, json, path, zone, query—but none is identified as the Jira issue key. Their descriptions (e.g., 'Git ref name', 'City name for a public weather hint') are irrelevant to checking a Jira key shape, so a caller cannot determine which parameter to pass.

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 essentially restates the tool name: 'Check a Jira issue key shape' adds little beyond 'jira-key-shape'. It does not explain what a valid shape is or what the tool returns, and the parameter list contains no obvious 'key' field, making the purpose ambiguous in practice.

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 shape-checking tools like domain-shape, figma-url-shape, or github-repo-shape. No prerequisites, expected inputs, or conditions for selection 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?

The only behavioral disclosure is that the body is discarded. There are no annotations to supply safety or side-effect information, and the description does not mention auth, errors, rate limits, or what happens with the non-URL inputs. With the full burden on the description, this is insufficient.

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

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

Two sentences with no filler, and the primary outcome is front-loaded. But the qualifying phrase 'public library docs URL' does not match the broader set of input fields in the schema, so the brevity comes at the cost of accuracy.

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?

A seven-parameter tool with no annotations and no output schema needs more than one narrow sentence. The description omits return format, error behavior, and how to interpret non-URL inputs, leaving an agent without enough context to call it correctly in most 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?

All seven parameters have schema descriptions that state whether they are normalized, validated, or discarded, so the description itself does not need to repeat that. It does add a small unspoken emphasis on the URL parameter, but no additional semantic detail beyond the schema.

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

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

The description names a concrete action (getting an HTTP status) and a resource (a public library docs URL), so it is not a tautology. However, the associated schema contains seven disparate parameters (city, feed, json, path, etc.), and the description does not explain how these relate to the stated purpose, nor does it differentiate the tool from sibling tools like fetch-status or browser-url-ok.

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

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

There is no guidance about when to use this tool versus alternatives such as fetch-status, normalize-url, or url-shape tools. The description gives no context, prerequisites, or exclusion criteria, so an agent has to guess at the intended selection policy.

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 values are discarded, which is a useful behavioral signal and implies a read-only counting operation. However, it does not explain return format, error behavior, or what 'discarded' means operationally.

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

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

Two short sentences with no filler. The primary action is front-loaded, and the additional behavioral note ('Values discarded') earns its place.

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

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

The tool has nine optional parameters, no output schema, and no annotations, yet the description does not explain which parameters to supply or what the return value represents. The gap between the described purpose and the actual schema makes correct invocation unclear.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds no parameter-level meaning, and the schema descriptions only say that parameters are discarded; they do not identify which parameter is the JSON object whose keys are counted.

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 states a concrete operation ('Count keys') on a resource ('a JSON object') and adds that values are discarded. However, it does not connect to the tool's 'memory' name or clarify which of the nine input parameters supplies that JSON object, so it is clear but not fully self-contained.

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 siblings such as validate-json, hn-front-count, or search-query-len. There are no conditions, exclusions, or alternatives mentioned, so an agent cannot decide between this and related count/validation tools.

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

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

With no annotations present, the description carries the burden of behavior. It clearly discloses that query and fragment are dropped, which is non-obvious and important. However, it does not mention error behavior, case normalization, or that the many unrelated schema properties are ignored, so it is not fully transparent.

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 that front-loads the verb and resource, and every word earns its place. It avoids fluff and is appropriately sized for the simple stated 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?

There is no output schema or annotations, so the description must stand alone. It explains the core return values but does not cover error handling, the definition of 'origin', or the presence of the many unrelated schema parameters. An agent would be under-informed when deciding to invoke it or constructing the call, especially with the confusing 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 description only adds semantic detail for the 'url' parameter (query/fragment dropped) and says nothing about the six other schema properties (ref, city, feed, host, json, path). Schema coverage is low (<50%), and the description does not compensate or clarify why those parameters exist or whether they are 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 clear verb ('Return') and resource ('a URL'), and specifies the exact outputs: origin, host, and path. It also adds the distinguishing behavior of dropping query and fragment. However, it does not explicitly differentiate from sibling URL tools like browser-url-ok or playwright-url-ok, so it stops short of a 5.

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

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

No guidance is given for when to use this tool versus alternatives. The description only explains what it does, not the context or exclusions. For example, it doesn't say to avoid it when needing full URLs, validation, or 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 present, so the description carries the full burden of behavioral disclosure. It reveals only that no browser is launched. It does not clarify whether the tool performs a network request, what kind of check is executed, how errors or timeouts are handled, or what a positive/negative result looks like. The disclosed trait is true but 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 exactly two short sentences, front-loaded with the core purpose and followed by a key constraint. There is no filler or redundancy; each sentence earns its place.

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

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

Given a tool with a ten-parameter schema and no output schema, the description is too sparse. It leaves unresolved why parameters like city, ref, or json are part of the schema, how the URL check relates to those params, and what the tool returns. An agent cannot confidently predict invocation behavior or output from this text 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?

All 10 parameters have individual descriptions in the schema, so schema coverage is 100%. The tool description itself contributes zero parameter-level meaning, but per the rubric the baseline is 3 when the schema already documents parameters. The schema descriptions themselves are odd (many say the value is discarded), yet that is schema information, not something the description needs to duplicate.

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 verb and resource: 'Check whether a URL can be opened.' It also adds a differentiating constraint, 'No browser is launched,' which hints at sibling distinction. However, it does not define what 'can be opened' means (e.g. HTTP status, port accessibility) nor explicitly contrasts with more than the browser-launching 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 explicit statement about when to use this tool over alternatives like browser-url-ok, fetch-status, or web-fetch. The 'No browser is launched' note provides an implicit hint but not a clear decision rule or exclusion of other 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?

No annotations are provided, so the description carries the full transparency burden. It does disclose that the query is discarded, which is a meaningful side-effect statement. However, it does not mention the return format, possible errors, or whether the unrelated optional parameters are ignored, leaving some behavioral gaps.

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

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

The description is a single concise sentence with no fluff, repetition, or unnecessary detail. It directly communicates the tool's function and a relevant behavioral note in a compact form.

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

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

There is no output schema, and the description does not explicitly state the return value (e.g., an integer character count). It also does not address behavior when 'query' is omitted, even though all parameters are optional, nor does it clarify the role of the eight unrelated optional parameters. The core idea is present, but these gaps reduce completeness.

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

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

Schema description coverage is 100%, so the baseline is 3. The 'query' parameter is clearly described as search text and is consistent with the tool purpose. However, the other eight optional parameters are unrelated to the stated purpose, and the description does not explain why they exist or whether they are ignored, which creates ambiguity despite individual field descriptions.

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

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

The description clearly states the tool's purpose with a specific action ('Count characters') and resource ('search query'), and explicitly notes that the query is discarded. The tool name reinforces this. It is immediately understandable what the tool does.

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

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

The description is self-explanatory for the core use case, but it does not explicitly indicate when to use this tool versus any alternative, nor does it mention edge cases or conditions. There are no sibling tools with similar names, but no direct usage guidance is provided either.

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 does not state whether the tool is read-only, what it returns, whether inputs affect the output, or any side effects. 'Short catalog' implies a safe lookup but does not explicitly disclose 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 compact sentence with no filler or redundant phrasing. It front-loads the core subject. However, it is so brief that it borders on under-specification, so it earns slightly less than a perfect score.

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 input parameters, no annotations, and no output schema, this description is markedly incomplete. It does not say how the parameters relate to the catalog, what the catalog contains, or what an agent should expect in the 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?

The input schema already includes descriptions for all seven parameters, so schema coverage is high and the baseline is 3. The tool description itself adds nothing about parameter semantics; the parameter descriptions are individually meaningful, even if their connection to the catalog is not explained.

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

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

The description names a concrete resource ('HTTP status codes') and indicates the tool provides a 'catalog,' which is enough to infer the general purpose. It lacks an explicit verb like 'return' or 'list,' but the noun 'catalog' communicates the intended resource and distinguishes it from sibling tools like fetch-status.

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

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

The description provides no guidance about when to use this tool, what kinds of queries it answers, or how it differs from alternatives. An agent is left to infer that a 'status catalog' is meant for looking up HTTP status codes, but no explicit context or exclusions are given.

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

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

No annotations are provided, and the description does not disclose any side effects, permissions, or predictable behavior. The phrase 'Prompt discarded.' is cryptic and does not clarify what happens to the input or what the tool returns.

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, but it is vague and lacks clear structure. It is not wordy, yet it fails to convey useful information efficiently.

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

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

With 9 optional parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain the return format, how parameters relate, or what a 'three-step thinking template' entails, leaving an agent without sufficient context 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%, meeting the high coverage baseline. However, the tool description itself does not elaborate on the parameters; the schema descriptions are present but appear arbitrary and unrelated to the stated purpose, limiting meaningful 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 says 'Return a three-step thinking template' which closely restates the tool name 'think-steps', making it tautological. It does not specify what the template contains or why it is distinct from sibling tools, and the second sentence 'Prompt discarded.' adds confusion rather than clarity.

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 any of the many sibling tools. There is no mention of context, prerequisites, or alternatives.

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

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

With no annotations, the description must stand alone. It only says 'current time' without disclosing error behavior, return format, or side effects. The schema parameter notes (e.g., 'discarded after the shape check') suggest a validation behavior that contradicts the timezone purpose, but no such behavior is described.

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, but it is under-specified—it omits the essential input parameter and any caveats. Under-specification is not conciseness; the absence of necessary context makes it inadequately 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?

There are no annotations, no output schema, and a complete mismatch between the description and the input schema: the timezone parameter described in the tool name is entirely absent. An agent would have no way to call this tool correctly given the provided information.

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

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

The schema lists seven parameters (ref, url, city, feed, host, json, path) none of which is a timezone. Their descriptions are about unrelated domains and several are 'discarded'. The tool description mentions 'named IANA timezone' but provides no mapping to any schema parameter. An agent cannot determine what input to provide, making the parameter semantics unusable.

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 function: returning the current time for a named IANA timezone. This is a specific verb+resource and distinguishes from siblings like utc-time. However, it does not mention how the timezone is provided, and the schema lacks any timezone parameter, which complicates the agent' understanding in practice.

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 utc-time or iana-zones. The description only states what it does, leaving usage context entirely implicit.

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

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

With no annotations, the description carries the behavioral disclosure burden. It only states 'Current UTC timestamp' and does not clarify output format, that no parameters are needed, or whether the call is side-effect-free.

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, zero-waste phrase. Every word earns its place and there is no redundant elaboration.

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

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

The tool has no output schema and no annotations, yet the description does not specify the return format (e.g., ISO string vs epoch) or note that all params are optional. Simple as the tool is, the description leaves too much for the agent to infer.

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 baseline is 3. The description adds no parameter meaning, and none of the 9 optional params are explained as relevant to the tool; several are described in the schema as discarded, but this is not reflected in the tool description.

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

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

Description states the tool returns the current UTC timestamp, which is a clear verb+resource. It does not explicitly distinguish itself from sibling timezone/iana-zones, but the UTC specificity provides enough clarity.

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

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

No guidance on when to choose utc-time instead of timezone, iana-zones, or other time-related siblings. No exclusions or alternative routing hints are given.

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

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

With no annotations, the description carries the burden of disclosing side effects; it does state 'The body is discarded,' which reassures callers that input is not retained. However, it does not disclose return behavior, error handling for invalid JSON, or any other runtime characteristics, 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 two short sentences with no filler. The primary action is front-loaded, and the additional side-effect note is information-dense.

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

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

Given the simple validation purpose, the description plus schea is minimally sufficient for an agent to call the tool with the json param. But the description is ambiguous about which argument constitutes the 'body,' does not state what result is returned, and provides no output schema, leaving the call contract incomplete.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters, including the json parameter for JSON text to validate. The description itself adds no parameter-level meaning and does not explicitly tell the agent that json is the relevant field, though the schema does.

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 verifies whether a body is syntactically valid JSON, using a specific verb and resource. It is distinguishable from sibling shape-validators like domain-shape or file-path-ok, though 'body' is slightly ambiguous without reference to the json parameter.

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

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

No guidance is given about when to use this tool instead of sibling validation tools, nor any exclusion or alternative. The purpose implies JSON validation use, but the description does not articulate selection criteria or when not to use it.

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

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

No annotations are provided, so the description carries the full behavioral burden. It states only the function, with no mention of side effects, network behavior, data source limitations, or what gets discarded. It does not contradict any annotation, but it also discloses almost nothing beyond the basic purpose.

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

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

The description is a single efficient sentence with no filler. It front-loads the core capability and cites the data source without any redundant phrasing.

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

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

Given the tool has seven optional parameters and no output schema, this description is not enough for an agent to call it correctly. It does not explain what to pass, what the response looks like, or how the unrelated schema fields relate to the tool.

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

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

The schema has 100% parameter descriptions, but they are largely inconsistent with the weather purpose; fields like ref, url, json, and path are unrelated decoys. The description adds only the Open-Meteo source and fails to clarify that city is the operative parameter or that the others 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 clearly states a specific capability: getting the current temperature for a city using Open-Meteo. It is a well-defined verb-resource pair and is distinct from the sibling tools, none of which claim weather functionality.

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 alternatives, nor any mention of required input conditions. The description does not tell the agent which parameter to provide or how to handle the many unrelated schema fields.

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 explaining behavior. It only discloses that the body is discarded and that HTTP status/content type are returned; it does not mention redirects, errors, timeout behavior, or how the other parameters 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 concise sentence with no filler. It could benefit from a short usage note given the parameter count, but it is not verbose or redundant.

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 parameters, no output schema, and no annotations, the description is too sparse to be complete. It lacks examples, expected output format, error behavior, and any explanation of how the varied parameters fit into the tool's 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?

Every parameter has a schema description, but most are vague or imply they are discarded after validation. The description does not clarify how a URL fetch relates to parameters like city, zone, query, path, or json, leaving their actual role and interaction unexplained.

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

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

The description states a clear action and resource: returning HTTP status and content type for a public URL while discarding the body. However, it does not distinguish this tool from sibling tools like fetch-status, which likely serve a similar 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 guidance is given about when to use this tool versus the many related siblings (fetch-status, browser-url-ok, normalize-url, etc.). The description also does not explain what to do with the many optional parameters or when they are relevant.

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 behavioral disclosure burden. It does disclose that the title is discarded after the call, which is useful privacy context, but it does not mention whether the operation is read-only, performs a network lookup, or returns any 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 very short and front-loads the core purpose. The second sentence about discarding the title is arguably useful privacy information, but the overall terseness leaves important semantic gaps.

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

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

For a simple existence check, the description might be sufficient if the title parameter were obvious, but the schema mismatch makes it hard to invoke correctly. There is also no mention of return format or output semantics, despite there being no output schema to fill that 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 input schema lists seven parameters with individual descriptions, but none of them is clearly a Wikipedia title. The description fails to bridge 'title' to any schema property, so an agent cannot determine which argument to supply.

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') on a specific resource, which clearly defines what the tool does. It is distinct from sibling tools such as file-path-ok or validate-json, even without naming alternatives.

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 a use case: verifying a Wikipedia title's existence. However, it gives no explicit guidance on when to prefer this tool over alternatives, no exclusions, and no context about prerequisites or expected inputs.

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