ISO country NA

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

With no annotations provided, the description carries the full burden. It usefully discloses that task text is discarded and lists what the tool returns. However, it does not clarify whether any of the nine optional parameters affect behavior, whether there are network or cost implications ('pay-per-call' hints at financial concerns), or whether the tool is purely read-only.

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

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

The description is brief and front-loaded with the core purpose. The output list and the caveat are each useful and non-redundant. It loses a point only because the unexplained term 'Monid' and the unclear parameter story make the concision feel slightly incomplete rather than optimally compact.

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

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

Without an output schema or annotations, the description must fully support invocation, and it does not. It never states that the tool can simply be called with no arguments, that all nine optional parameters are effectively ignored, or what 'Monid' is. The output list helps, but the invocation contract remains ambiguous given the strange set of unrelated optional parameters.

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

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

Schema description coverage is 100%, so each parameter already has an explanation. The description adds the blanket statement 'Task text discarded,' but it does not address the relationship between the nine varied optional parameters and the tool's stated purpose. An agent still cannot tell which parameters, if any, are meaningful, so the description adds no real parameter semantics 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 uses a specific verb and resource: 'Find a public pay-per-call tool gateway (Monid)' and lists concrete outputs such as CLI setup, how-it-works, skill file, and remote MCP hops. This distinguishes it from the sibling utility tools, though 'Monid' itself is left unexplained, which prevents a perfect score.

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

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

The description implies when to use the tool: when the agent needs Monid gateway setup information. The note 'Task text discarded' provides a when-not caveat against passing arbitrary task content. However, it does not explicitly say no arguments are needed or name any alternative, leaving the invocation context somewhat 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?

The description does disclose one meaningful behavioral trait: no browser is launched, which is important for a tool named 'browser-url-ok'. However, with no annotations, the description still leaves open major questions such as whether a network request is made, whether the operation is read-only, and what happens for invalid inputs.

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

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

The definition is very lean and front-loaded: purpose first, behavioral qualifier second, with no filler or repetition. It loses one point because the brevity leaves out necessary context for a tool with nine optional parameters and no output schema.

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 mention return type, required inputs, error behavior, network side effects, or which of the nine optional parameters actually matters. For a tool with a browser-related name and a broad, mismatched parameter list, this is too incomplete for reliable agent 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?

Although every parameter has a schema description, those descriptions are poorly aligned with the tool's purpose: the schema includes city, timezone, json, query, and ref fields, and even the 'url' description says 'normalize or cite' rather than checking openability. The tool description adds no clarification about which parameter to pass, so the 100% schema coverage does not effectively guide invocation.

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

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

The description states a specific action ('Check whether a URL can be opened') and adds a useful qualifier ('No browser is launched') that separates it from Playwright-based alternatives. It is not a 5 because 'can be opened' is somewhat ambiguous: it could mean syntax validation, reachability, or browser compatibility, and no sibling tool is explicitly named.

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 siblings like playwright-url-ok, normalize-url, or web-fetch. The phrase 'No browser is launched' weakly implies a lightweight check, but the description never states when to prefer it 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?

With no annotations, the description carries the full burden, but it only states that the expression is discarded. It does not disclose whether the operation is read-only, what evaluation result is returned, whether any input is persisted, or what errors occur.

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

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

The description is very short and front-loaded with the main action; there is no filler. Brevity is gained at the cost of clarity, but conciseness itself is effective.

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

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

For a tool with nine unrelated parameters, no annotations, and no output schema, this two-sentence description is far from complete. It omits return behavior, parameter mapping, side effects, and failure modes.

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

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

Although schema coverage is 100% and each property has its own description, the tool description never explains which of the nine fields should contain the arithmetic expression—or whether any of them do. The 'a+b' concept is disconnected from the schema, so an agent cannot reliably determine what 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 gives a concrete action ('Evaluate a+b style arithmetic') and a clear resource, which separates it from sibling validation/checking tools. However, it does not connect the expression to any of the nine input schema fields, and 'Expression discarded' muddies what the tool ultimately returns.

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

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

Usage is only implied by the phrase 'a+b style arithmetic' rather than stated with conditions or alternatives. No when-to-use/when-not-to-use guidance is given relative to the many sibling tools, so an agent must infer applicability.

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 line 'Page content is not stored' provides a useful behavioral and privacy guarantee beyond what the schema offers, and annotations are absent. However, the description does not state side effects such as whether a live network request is made, rate limits, or how the various 'discarded' parameters affect behavior. The schema notes help but are scattered.

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

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

Two concise sentences with no filler. The primary result is front-loaded, and the additional privacy note earns its place.

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

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

For a tool with nine optional parameters and no output schema, the description covers only the URL behavior and ignores the rest of the inputs. It lacks examples, output format, and guidance on the auxiliary parameters, making it incomplete for agents that need to invoke 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?

Schema coverage is 100%, so the input schema already documents every parameter. The description adds meaning by implying url is the primary parameter and that page content is not persisted, but it does not clarify how ref, feed, city, json, or host relate to the citation workflow.

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 output: 'Return host, scheme, and HTTP status for a URL.' It names the resource and the result, and adds a distinguishing privacy trait. It does not fully explain the 'citation' name or differentiate this from similar siblings like fetch-status, normalize-url, and web-fetch, so it is not a 5.

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

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

No guidance is given on when to use this tool versus fetch-status, normalize-url, browser-url-ok, or web-fetch. The description says what it does but not when it is the right choice, nor does it mention any exclusions. With a long sibling list, this is a significant gap.

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; it does disclose a meaningful privacy behavior – no identifiers are retained. However, it does not state whether the tool is read-only, whether it performs network access, or what happens to the provided values beyond the parameter-level 'discarded' notes.

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 sentences are front-loaded and contain no filler; the privacy note earns its place. It is concise, though brevity comes at the expense of the contextual detail needed for safe routing.

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

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

For a nine-parameter classifier with no output schema and no annotations, the description omits critical context: what classification is returned, how to choose a parameter, and how this tool relates to the sibling validators. The privacy note and schema descriptions cover only a fraction of what an agent needs.

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

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

Schema coverage is 100%, so the schema already describes each parameter in usable detail (e.g., 'Git ref name; discarded after the shape check'). The description adds no guidance about whether the nine optional parameters are mutually exclusive or which one to supply for a given request, so it stays at the baseline.

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

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

The description states a clear intent – show the classification of a request – but 'this request' is never defined, and no classification categories or expected outputs are given. It does not distinguish compatibility from sibling shape-checking tools like domain-shape or file-path-ok.

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

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

No sentence addresses when to use this tool instead of the 27 sibling tools. There are no alternatives, exclusions, or conditions such as 'when you need to route a request' or 'instead of calling validators directly.'

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 usefully discloses that the tool performs no WHOIS or ownership lookup, implying a pure lexical operation. It does not mention how irrelevant input fields are handled or what the returned labels look like, but the stated exclusion covers the main risk.

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 focused sentence with no filler: the verb and object are front-loaded, and the exclusion ('without WHOIS or ownership data') adds meaningful scope in few words.

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

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

The tool is simple and schema coverage is complete, but with nine optional parameters and no output schema, the description leaves room for ambiguity about which parameter to populate and what exact return structure to expect. It is workable but not fully self-sufficient.

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 schema already documents all nine optional string parameters. The description only implies the relevant field is 'host' via 'hostname' and adds no parameter-specific 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 specific operation (split), a specific resource (hostname), and a concrete outcome (labels), and explicitly excludes WHOIS/ownership data. This distinguishes domain-shape from sibling shape/URL tools such as github-repo-shape 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 phrase 'without WHOIS or ownership data' gives a clear negative boundary: use it for syntactic hostname parsing, not ownership lookup. However, it does not name sibling alternatives or provide explicit when-to-use/when-not-to-use conditions.

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

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

With no annotations, the description carries the full transparency burden. It does disclose 'status only' and the HEAD method, but it says nothing about auth, rate limits, redirects, return format, or the fact that most schema parameters appear to be validated or discarded rather than fetched.

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

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

The description is a single front-loaded sentence with no wasted words, but it is under-sized for a nine-parameter tool with no output schema and no annotations. It is concise rather than appropriately specified.

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

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

Given nine optional parameters, no output schema, and no annotations, the description is far from complete. It does not explain what status values are returned, which parameters select which behavior, or when this tool should be preferred over siblings.

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

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

Schema description coverage is 100%, so the baseline is 3 and the individual parameter descriptions add useful meaning such as 'discarded after the shape check' and 'no disk access'. The tool description itself adds no parameter semantics and its URL-only wording conflicts with the non-URL parameters.

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

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

The description names a specific verb, resource, and output: HEAD a public URL and return status only. However, the input schema exposes nine unrelated optional parameters such as ref, city, feed, json, path, and query, so the description does not state the tool's actual overall scope and may mislead an agent into thinking only `url` is relevant.

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 when-to-use guidance or mention of alternatives. Sibling tools such as web-fetch, browser-url-ok, playwright-url-ok, and normalize-url are not differentiated, so an agent has no criteria for selecting this tool over them.

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

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

With no annotations, the description carries the full burden. It discloses one behavior, that the path is discarded, but it does not say whether the URL is validated, how the URL and other parameters interact, what is returned, or whether the operation is read-only.

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

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

Two short sentences with the main action front-loaded and no filler. The second sentence is cryptic but not verbose; it is compact enough that an agent can grasp the tool's core purpose quickly.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, this description is too thin. It does not explain which parameter is the Figma URL, what a successful parse returns, or what failure looks like, so an agent is left with significant ambiguity.

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

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

The schema description coverage is 100%, so the baseline is met; the schemas already document each parameter. The description adds no new parameter meaning except 'Path discarded', which merely restates what the path parameter's schema already says.

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 parses a Figma file URL. This is enough to distinguish the tool from generic URL tools like normalize-url by the target resource, though it does not say what 'shape' means or what the parse result is.

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 implies the tool should be used when a Figma file URL needs to be parsed or shape-checked, but it gives no explicit conditions, exclusions, or pointer to sibling tools such as normalize-url or browser-url-ok. No prerequisites 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?

With no annotations, the description must carry behavioral disclosure. It does disclose one meaningful non-obvious trait: 'No disk access', which tells the agent this is a side-effect-free, local-only check. But it is silent on what the return value is, what 'safe' means, or how it handles the nine unrelated-looking optional parameters, leaving a significant transparency gap.

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

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

Two short sentences, each earning its place: the first identifies the purpose, the second adds a key constraint. The description is front-loaded and free of filler, making it easy to scan.

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 9-parameter tool with no output schema and no annotations, the description is too sparse. An agent cannot tell whether it returns a boolean, error, or report, or what path shapes count as 'safe'. The presence of many unrelated parameters in the schema compounds the incompleteness.

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 a description; the tool description adds no parameter detail beyond the word 'path'. This meets the baseline for high schema coverage but does not elevate it, and it fails to clarify why the schema also contains url, city, feed, etc., which could confuse an agent.

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 ('Check') and resource ('a path'), and adds the constraint 'No disk access', which signals a lightweight static validation. However, it does not define what 'safe' means, and it doesn't explicitly differentiate from sibling 'ok' tools like browser-url-ok or wiki-title-ok, beyond the path/disk mention.

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 normalize-url or browser-url-ok. The 'No disk access' hint implies it is a pure syntactic pre-check, but the description never states that explicitly as a usage condition, nor lists 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, the description carries the full behavioral burden, but 'via Open-Meteo' only hints at an external service. It does not disclose input requirements, read-only behavior, discarded fields, network dependence, or output format.

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

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

The description is one tight sentence with no filler and front-loads the main result: coordinates. It is efficient, though it omits important usage and parameter details.

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

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

For a tool with nine optional parameters, no output schema, and no annotations, this description is not complete enough. An agent cannot determine which parameter identifies the place or what the response will look like.

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

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

Schema coverage is 100%, so the baseline is 3. The phrase 'a place' adds general meaning but does not clarify which of the nine optional parameters should be used, even though city is likely the relevant one.

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 provides latitude and longitude for a place and names Open-Meteo as the provider. It is specific enough to identify the core function, though it lacks a verb and does not distinguish it from sibling tools like weather-hint.

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

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

There is no guidance on when to use this tool versus alternatives such as weather-hint, timezone, or iana-zones. No prerequisites, exclusions, or alternative routing are mentioned; the intended use is only implied by 'for a place'.

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 weight; 'Parse' suggests a local, non-mutating operation, which is useful. However, it does not state that no network request is made, how malformed URLs are handled, or whether the ref parameter affects parsing.

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

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

The description is a single front-loaded sentence with no wasted words; the verb and primary input appear immediately. It could be slightly more structured to include guidance about ignored parameters, but as written it is concise and readable.

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 parse task the core input/output is stated, and the 100% schema coverage fills in parameter descriptions. But there is no output schema, no annotations, and no mention of handling invalid URLs or which of the nine optional parameters are actually relevant, so the description is not fully self-sufficient.

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 applies and the schema already documents the parameters. The description adds no parameter-level detail, and with nine optional parameters including city, feed, host, and query, it does not explicitly identify url as the key input beyond the word 'URL.'

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 ('Parse'), a precise input class ('GitHub URL'), and the exact output ('owner and repo'). This is enough to tell github-repo-shape apart from sibling shape tools like domain-shape or figma-url-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?

It clearly implies use when a GitHub repository URL needs owner/repo extraction, but it does not state when to prefer a sibling tool, nor give exclusions such as 'for non-GitHub URLs use domain-shape.' The usage condition is present but only implicitly differentiates from 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 carries the burden. It adds useful context ('current' live data, 'Titles discarded'), but does not disclose return format, failure behavior, or whether any of the nine optional parameters affect the count. This is partial 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?

Two short sentences with no filler; the purpose is front-loaded and the caveat is a deliberate second sentence. Every word earns its place.

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

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

The tool has nine optional parameters, no output schema, and no annotations, yet the description does not explain how those parameters relate to the count, whether they are ignored, or what the response looks like. The mismatch between the generic-looking schema and the specific HN count is left 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 description coverage is 100% and every parameter already has a description in the schema, so the baseline is 3. The tool description adds no parameter-level meaning and does not explain which parameter, if any, drives 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 opens with a specific verb ('Count') and a precise resource ('current Hacker News front-page stories'), and the clause 'Titles discarded' narrows the output scope. This is enough for an agent to know what the tool does and to distinguish it from generic fetch or status tools.

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

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

No explicit guidance is given about when to choose this over siblings like web-fetch or fetch-status, nor any exclusions or prerequisites. The only usage signal is the implied one: use it when you need the Hacker News front-page story count.

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

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

With no annotations provided, the description carries the burden of disclosing behavior. It only says 'common,' implying a non-exhaustive set, but it does not explain side effects, read-only nature, return behavior, or how the tool treats the many optional input parameters, several of which 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 very short and contains no redundant wording, which is a plus for conciseness. But it is also under-specified: it reads more like a label than a tool description, and the single noun phrase lacks the structural elements of a useful 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?

This tool has no output schema, no annotations, and 9 optional parameters whose descriptions do not align with timezone names. The description does not tell the agent what the tool returns, whether parameters are needed, or how to interpret the odd param set, making the calling contract unclear.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning, but the schema already documents each property. However, the parameters themselves seem unrelated to IANA timezone names, creating confusion that the description does nothing to resolve.

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 statement of action. 'Common IANA timezone names for clock calls' does not say whether the tool returns, lists, validates, or selects these names. It is only slightly more informative than the tool name 'iana-zones' and gives no clear operation.

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

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

The phrase 'for clock calls' hints at when this tool might be relevant, but it is not explicit guidance. It does not name alternatives like timezone or utc-time, nor does it explain when this tool should be used versus another time-related sibling tool.

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

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

With no annotations, the description carries the behavioral disclosure burden. It clearly discloses a network fetch of a public resource and a reduced return value ('group counts only'), but it does not describe failure behavior, redirects, or how 'groups' are defined.

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

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

The description is a single front-loaded sentence with no filler. It communicates the action and output constraint in minimal words, and every phrase 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 no annotations, no output schema, and nine optional parameters, yet the description does not identify which input selects the target robots.txt or describe the returned count structure. This is not enough context for an agent to invoke the tool correctly without guessing.

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%, which typically earns a baseline of 3, but the schema parameters are largely unrelated to fetching robots.txt (city, feed, json, ref) and the description never says which parameter is the fetch target. An agent cannot reliably determine whether to populate url, host, or another field.

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

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

The description states exactly what the tool does: fetch a public robots.txt and return only group counts. The verb, resource, and output constraint are specific, and this clearly distinguishes it from generic fetchers like web-fetch or status checkers 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 phrase 'public' and 'group counts only' implies the tool is for cases where only robots.txt group summaries are needed, not full content. However, it never names alternatives or explicitly says when not to use this tool, leaving the selection partly 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 provided, the description carries the full burden. 'Key discarded' is a useful disclosure that the input key is not retained or returned, which is genuinely informative. But the description does not state whether the tool returns a boolean, an error, or a shape result, nor whether any external/network validation is involved.

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

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

The description is very concise: two short sentences with the purpose front-loaded and no filler. Every sentence adds a distinct fact: what it checks and that the key is discarded. A minimal example of a valid Jira key shape would improve it, but for its length it is 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?

The definition is incomplete for confident invocation: it does not specify the actual input parameter for the Jira key, what the valid shape is, or what the return value means. The noisy input schema with many unrelated properties and the absence of an output schema or annotations make this insufficient for an agent to use 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?

The description references a 'key', but the visible input schema properties are ref, url, city, feed, host, json, and path — none of which clearly maps to a Jira issue key. Several properties are even marked as 'discarded', which suggests they are irrelevant, yet the description provides no mapping from 'key' to a schema parameter. This leaves invocation ambiguous.

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

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

The description states a specific verb 'Check' and a clear resource, 'Jira issue key shape', which distinguishes it from sibling shape-checkers by domain. The phrase 'Key discarded' also clarifies that this is a validation-only operation, not a retrieval. However, it does not specify what input parameter carries the key or what the expected output is.

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 name and description imply the use case: when an agent needs to validate whether a string is shaped like a Jira issue key. However, there is no explicit guidance about when NOT to use it or which sibling tool to prefer, and the relationship to tools like github-repo-shape or wiki-title-ok is unaddressed.

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 bears the full burden of disclosure. It does add one behavioral trait ('Body discarded'), but it omits how the other parameters are treated, whether the URL must be a library docs URL to receive a meaningful status, or any side effects. The scope of 'public library docs URL' is undefined.

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 with two sentences that each carry distinct information: the primary function and the body-discarding behavior. No wasted words, though the brevity veers toward under-specification rather than effective 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?

The tool has 9 parameters, no annotations, and no output schema, yet the description is only 10 words. It fails to explain what the tool returns beyond 'HTTP status', which parameters are actually used for that purpose, or how the other parameters factor in. An agent cannot reliably invoke this tool correctly.

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

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

Schema description coverage is 100%, and each parameter's description already explains its purpose and discarding behavior. The tool description adds zero parameter-level meaning beyond the schema, so it holds at the baseline of 3.

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

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

The description states the tool yields an HTTP status for a public library docs URL, which names a resource and result type. However, it lacks an explicit action verb, doesn't distinguish it from sibling tools like fetch-status, and conflicts with the 9-parameter schema that includes unrelated fields (city, feed, json, zone). The term 'hint' further muddles the intended function.

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 such as fetch-status, browser-url-ok, or normalize-url. There are no exclusions, prerequisites, or context cues to help an agent choose this tool over 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 carry the full behavioral burden. It discloses that values are discarded, which is useful, but it does not say whether the input is validated, whether keys are counted at the top level only, what happens on invalid input, or what the return value is.

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

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

Two short, front-loaded sentences with no filler. Every word contributes to the tool's purpose or behavior, and the description is appropriately sized for a simple counting 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?

Despite a simple purpose, the tool exposes nine optional parameters and no output schema. The description does not say how to supply the JSON, which parameter to use, or what the count result looks like, leaving the agent to infer these essentials.

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 the parameters; this earns the baseline 3. The tool description adds the general purpose but does not map it to the 'json' parameter nor clarify whether the other optional parameters are alternatives or unrelated.

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

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

The description uses a specific verb ('Count') and resource ('keys in a JSON object'), and 'Values discarded' adds a concrete behavioral scope. It does not explicitly differentiate from sibling tools like validate-json or domain-shape, but the tool's name and sentence together make its primary function identifiable.

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

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

There is no guidance on when to use this tool versus alternatives such as validate-json or domain-shape. The description only states what the tool does, with no when-to-use, when-not-to-use, or alternative 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 burden of disclosure and does state a key behavioral trait: query and fragment are dropped. It does not, however, disclose that all parameters other than `url` are ignored or discarded, nor does it describe behavior for invalid or non-HTTPS URLs, leaving meaningful gaps in 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 two short sentences with no filler. The primary purpose is front-loaded, and the behavioral caveat about dropped query/fragment is placed immediately after, making it 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 nine parameters, no annotations, and no output schema, the description is too sparse. It does not explain why the schema contains many seemingly unrelated parameters that are all discarded, nor does it specify the exact return shape (e.g., an object with `origin`, `host`, and `path` fields).

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-specific meaning beyond the schema; it does not clarify how `url` maps to the output beyond the general statement about origin, host, and 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 states a specific action ('Return') and resource ('origin, host, and path for a URL'), and explicitly notes that query and fragment are dropped. This clearly distinguishes the tool from siblings like browser-url-ok or fetch-status, which check or fetch URLs rather than normalize them into components.

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 this tool should be used when a caller needs the origin, host, or path of a URL and does not care about query strings or fragments. However, it gives no explicit guidance about when to choose this tool over the many URL-related siblings, nor does it mention any exclusions or alternatives.

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

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

With no annotations, the description must carry the full behavioral disclosure burden, but it only reveals that a browser is not launched. It does not state whether a network request is made, what 'ok' means, what gets returned, whether parameters are normalized, or whether there are any side effects. The schema's 'discarded' notes help, but they are structured field descriptions, not substitute behavioral context in the tool description.

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

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

The description is very concise: two sentences, each carrying necessary information. The first sentence states the action, and the second reveals a key behavioral constraint. There is no fluff or repetition.

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

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

For a tool with nine parameters, no output schema, and no annotations, the description is too sparse. It does not explain the tool's return format, the meaning of an 'ok' result, the role of the many optional parameters, or how this tool relates to the sibling URL-checking tools. The schema covers parameters but not the operation-level context an agent needs.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters. The tool description itself adds no parameter-level meaning, which is acceptable given the high coverage, but it also does not clarify which parameters are central to the URL check or how they interact.

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

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

The description names a specific action ('Check') and resource ('a URL'), and the 'No browser is launched' sentence helps separate it from a browser-based check. However, 'can be opened' is ambiguous—it could mean syntactic validity, HTTP reachability, or some other notion of openability—and the schema's 'discarded after the shape check' hints at a broader shape-validation behavior that the description does not mention.

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

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

There is no explicit guidance about when to use this tool versus alternatives like browser-url-ok, fetch-status, or normalize-url. The only hint is the negative constraint 'No browser is launched,' which weakly implies a lightweight check but does not state prerequisites, exclusions, or selection criteria.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It does disclose that the query is 'discarded,' which is useful, but it omits other important behaviors: return format, error handling, whether only the query parameter is used, and whether the other eight schema fields are ignored. For a tool with no annotations, this is thin.

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

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

The description is two short sentences with no filler. 'Count characters in a search query' states the core operation, and 'Query discarded' adds a meaningful behavioral note. Every word earns its place.

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

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

Given nine optional parameters, no output schema, and no annotations, this description is not complete enough. It does not explain what the tool returns, which parameter to use, or why the schema contains fields like url, city, feed, and host. An agent could easily misuse the tool by passing the wrong parameter.

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

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

Schema description coverage is 100%, so the schema already documents each of the nine parameters in detail. The main description adds little beyond aligning 'search query' with the query parameter. It does not clarify which parameter an agent should actually populate or that the other parameters appear unrelated to 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 clearly states a specific action and resource: 'Count characters in a search query.' It is not a tautology and the resource ('search query') differentiates it from sibling count/validation tools. However, it does not explicitly distinguish itself from similar siblings like memory-key-count or hn-front-count.

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 the many sibling shape/validation/count tools. It does not mention conditions, exclusions, or alternatives. An agent is left to infer usage from the name and description alone.

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

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

No annotations accompany this tool, so the description carries the full burden of behavioral disclosure. The word 'catalog' weakly implies a read-only operation, but the description discloses nothing about what happens to the inputs, whether the call mutates anything, what the response contains, or why parameters are 'discarded after' checks. The schema hints at shape-checking behavior, but the description contributes no behavioral transparency of its own.

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?

Seven words is under-specification, not conciseness. There is no front-loaded action, no scoping constraint, and no differentiating signal — the sentence merely echoes the tool name rather than earning its place by adding 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?

With 8 parameters, no annotations, no output schema, and 27 sibling tools, this definition is severely incomplete. The description does not explain the return value, edge cases, rate limits, or what 'catalog' means operationally. An agent cannot reliably decide to call this tool or construct a meaningful request from what is provided.

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 (all 8 params have descriptions), which sets a baseline of 3, but the description fails to add any meaning that ties these heterogeneous parameters (Git ref, city, RSS feed, JSON text, file path) to the stated purpose of an HTTP status code catalog. The schema's own notes about values being 'discarded after the shape check' actively suggest a different underlying behavior than the description conveys, leaving agents confused about how to populate parameters correctly.

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

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

The description 'Short catalog of common HTTP status codes' merely restates the tool name 'status-catalog' with slightly more words, making it close to a tautology. It names a noun resource but never states the verb or operation performed — does it look up a code, list all codes, or validate something against a code? The eight input parameters (ref, url, city, feed, host, json, path) bear no evident connection to HTTP status codes, so an agent cannot infer what the tool actually does with them.

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 zero guidance on when to use this tool versus alternatives. Among the 27 siblings are fetch-status, web-fetch, and domain-shape, which plausibly overlap with HTTP/status-related tasks, but the description never distinguishes this tool from them or states conditions for selection.

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. It does disclose one important trait: the prompt is discarded, meaning the output is not customized. However, it does not clarify whether the optional parameters are ignored or how the returned template is structured, leaving notable 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?

Two short sentences, no filler, and the core purpose is front-loaded. Every word contributes, making this an appropriately concise definition for a simple template-returning tool.

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

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

Despite 9 optional parameters and no output schema, the description does not explain how to invoke the tool or what to pass. It never states that no arguments are needed or that the template is fixed, so an agent may be unsure whether to populate parameters like 'url', 'city', or '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 100%, so the baseline is 3. The tool description adds no parameter-level meaning beyond the schema. The description 'Prompt discarded' is too broad to clarify which of the nine optional parameters are 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 action and deliverable: 'Return a three-step thinking template.' This is enough to identify what the tool does. It is somewhat vague about the template's content, and it does not explicitly compare to sibling tools, so it misses the top score.

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

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

There is no guidance on when to use think-steps versus the many sibling tools. 'Prompt discarded' hints that the tool ignores the request, but it does not state when an agent should select this tool or when it should not.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only says the tool returns the current time; it does not mention validation, side effects, error behavior, or the fact that most input parameters appear unrelated or 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 and front-loaded with the core behavior, containing no filler. It is efficient, though almost too terse to convey the missing parameter relationship.

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

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

For a tool with nine parameters, no annotations, and no output schema, this one-sentence description is highly incomplete. An agent cannot determine which parameter to populate, what output to expect, or how to distinguish this tool from related timezone/weather utilities.

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

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

Although schema coverage is 100%, the nine documented parameters are unrelated to timezone lookup (e.g., ref, url, feed, json, path). The description does not indicate which parameter represents the IANA timezone or how the parameters relate to the tool's purpose, so it adds no useful semantic mapping.

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

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

The description names a clear resource and operation: 'Current time in a named IANA timezone.' However, the input schema contains no parameter for an IANA timezone, so the stated purpose cannot be mapped to the tool's actual inputs, making it misleading in context.

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 closely related siblings like utc-time or iana-zones. The description implies usage for getting a timezone's current time but gives no exclusions or alternative routing.

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

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

The description does not disclose that all input parameters are discarded, nor does it explain the purpose of the oddly named parameters such as 'Git ref name' or 'JSON text to validate'. Without annotations, the description carries the full burden, and it fails to clarify the tool's real behavior beyond returning a timestamp.

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, which is efficient and front-loaded. However, it is terse to the point of under-specification—concise but missing critical context about the parameter behavior. It earns a 4 for being compact, but not a 5 because it omits important 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?

Given the complex input schema with seven seemingly irrelevant parameters and no output schema, the one-line description is insufficient. It does not explain that the tool can be called with no arguments, that all parameters are ignored, or what the return format (e.g., epoch seconds vs. ISO string) looks like. The definition is incomplete 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?

The input schema provides descriptions for all seven parameters, but those descriptions are confusing in the context of a UTC timestamp tool (e.g., 'discarded after the shape check'). The description adds no clarification or additional meaning beyond what the schema already states, so it stays at the baseline for 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 'Current UTC timestamp.' states a specific verb (returns) and resource (UTC timestamp). It is clear about the core functionality, but does not explicitly distinguish it from sibling tools like timezone or iana-zones, so it doesn't fully earn a 5.

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

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

There is no guidance about when to use this tool versus alternatives. No mention of when not to use it, no reference to timezone or iana-zones, and no indication whether arguments should be passed. An agent is left to infer usage from the schema alone.

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

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

The description discloses that the body is discarded, which is useful side-effect information beyond the schema. However, with no annotations and no output schema, it fails to mention what the tool returns (e.g., boolean, error message) or what constitutes 'valid JSON'.

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 zero filler. The primary action is front-loaded and the discard behavior is stated concisely.

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 7 parameters, no annotations, and no output schema, the description is too thin. It does not explain the role of the other parameters (ref, url, city, feed, host, path), nor the return format or error behavior. An agent could not confidently know what to expect after calling it.

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

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

The input schema documents all parameters with descriptions, so coverage is high. The description adds nothing beyond 'body' (implicitly mapping to the 'json' parameter), so it provides no additional semantic 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 states a specific action ('Check whether a body is valid JSON') with a clear resource. It is distinguishable from sibling shape-checking tools like file-path-ok or wiki-title-ok, though it doesn't explicitly name an 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 given about when to use this tool versus sibling validation/shape tools. There is no mention of alternatives, prerequisites, or conditions that would make this tool the right choice.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It names Open-Meteo as the data source but does not mention output units, failure modes, network dependency, side effects, or that most schema parameters are discarded. This is minimal transparency for an external-data tool.

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

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

The description is a single front-loaded sentence with no filler. It communicates the essential purpose and data source efficiently, which is appropriate for a simple 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?

Despite the appearance of 9 optional parameters, the description does not clarify that city is the relevant input, nor does it explain the discarded nature of the other parameters. With no output schema and no annotations, the lack of return-format and error-behavior details leaves the definition incomplete for reliable invocation.

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

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

Schema description coverage is 100%, so each parameter already has meaningful documentation. The description adds no parameter-specific detail beyond the word 'city,' and the schema already describes the city parameter. This matches the baseline of 3 for 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 clearly states the tool returns current temperature for a city via Open-Meteo, which is a specific resource and function. However, it does not explicitly distinguish this tool from sibling tools such as geo-hint or lib-docs-hint, so it falls short of top marks.

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, no exclusions, and no context about prerequisites. It only states what the tool does, leaving the agent to infer usage from the weather-related 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?

No annotations exist, so the description carries the disclosure burden. It usefully reveals that the body is discarded and that the URL must be public, but it omits redirect behavior, error handling, response format, and the fact that many schema parameters are discarded after shape checks.

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 core behavior is front-loaded. 'Body discarded' is a necessary clarification that earns its place.

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

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

For a tool with nine optional parameters and no output schema, this is too sparse. It does not state which argument(s) to use for the fetch, what the response structure looks like, or how to handle the many discarded parameters. An agent could easily call it with the wrong parameter or misinterpret 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?

Schema description coverage is 100%, so the baseline is 3. The description adds minimal meaning beyond the schema: it clarifies that a public URL is the core input and that the body is discarded, but it does not explain how url relates to params like feed, host, json, path, city, query, ref, or zone.

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

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

The description clearly communicates that the tool returns HTTP status and content type for a public URL, and explicitly states that the body is discarded. It does not, however, differentiate this from siblings like fetch-status, browser-url-ok, or normalize-url, and it lacks a strong verb like 'fetch' or 'check'.

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 fetch-status, browser-url-ok, or normalize-url. The phrase 'public URL' hints at scope, but no conditions, exclusions, or alternative recommendations 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?

The sentence 'Title discarded after the call' adds a privacy/retention trait beyond the plain 'check' wording. However, with no annotations present, the description still omits obvious behavioral details such as whether the call is read-only, what the result shape is, and how errors are surfaced.

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; both sentences earn their place. It loses one point because the second sentence relies on the undefined 'title' concept rather than connecting to a schema parameter.

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 an agent to invoke this tool, the most critical fact - how to pass the Wikipedia title - is absent, and no output schema compensates. The mismatch between description and input schema leaves the tool unusable as documented.

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 implies a title input, but the schema exposes ref, url, city, feed, host, json, and path - none labeled as a Wikipedia title. The description adds no mapping or instruction for supplying the title, and the existing parameter descriptions are unrelated to the tool's purpose. This makes correct invocation impossible without guessing.

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: 'Check whether a Wikipedia title exists.' This is clear and not tautological. It earns a 4 rather than 5 because it does not differentiate wiki-title-ok from sibling validators such as browser-url-ok or domain-shape, and it gives no hint of which input parameter carries the title.

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 prefer this tool over sibling tools, nor any exclusion criteria. The intended use is only implied by the purpose statement, so an agent has no help choosing between wiki-title-ok and other *-ok/*-shape validators.

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