ISO country MW

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

With no annotations, the description carries the disclosure burden. It explicitly states task text is discarded, which is a meaningful privacy/behavioral trait, and it enumerates what is returned. It does not discuss pay-per-call cost side effects or remote execution risk, but the read-only 'find/return' framing is fairly 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 three short sentences with no wasted words: action first, outputs second, behavioral caveat third. Every sentence earns its place and the structure is 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?

The description lists the returned artifacts and gives a key behavioral caveat, which is adequate for a documentation-lookup tool. However, it never clarifies what Monid is or how the 9 optional parameters relate to finding the gateway, leaving the invocation contract somewhat ambiguous.

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

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

Schema description coverage is 100%, so all 9 parameters are already documented with notes like 'discarded after the shape check' and 'no disk access'. The description itself adds no parameter-level detail, so the baseline of 3 applies.

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

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

The description names a specific action ('Find'), resource ('public pay-per-call tool gateway (Monid)'), and returned artifacts ('CLI setup, how-it-works, skill file, remote MCP hops'). It differentiates itself from the sibling validator/hint tools by its output categories, although 'Monid' is left unexplained.

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: invoke this when you need to locate the Monid gateway and retrieve setup/skill documentation. It does not explicitly mention when not to use it, nor does it point to alternatives among the many sibling tools; 'Task text discarded' is the only implied limitation.

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 does disclose a key side-effect boundary ('No browser is launched') and the input schema repeatedly notes that values are 'discarded after the shape check' or similar, indicating no persistence. However, it remains silent on whether the tool makes an external network request, what error behavior looks like, or whether the check is only structural.

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, front-loaded sentence that states the core function and the most important behavioral caveat. Every word earns its place, and there is no fluff or redundant restatement of the tool name.

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

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

There is no output schema and no annotations, so the description must explain basic invocation and return semantics. It does not describe what the tool returns, how an agent should interpret 'ok,' or how the nine optional parameters relate to the URL check, making the definition incomplete for confident autonomous 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?

Schema description coverage is 100%, so the baseline is 3; every parameter has a textual description including discard behavior. The main description adds no parameter-level semantics, and there is lingering ambiguity because the tool is about URL checking but has nine optional, unrelated-looking parameters and does not say which one is the URL to check.

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

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

The description states a clear verb and resource: 'Check whether a URL can be opened.' The additional line 'No browser is launched' distinguishes it from browser-based siblings like playwright-url-ok. However, it does not specify what 'can be opened' means (syntax validation, DNS lookup, HTTP reachability), so it is not fully explicit.

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

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

The only usage signal is the phrase 'No browser is launched,' which implies a lightweight non-browser check and tells the agent it is not the tool to use when a real browser session is required. It does not explicitly name alternatives or describe when to prefer this tool over playwright-url-ok, web-fetch, or fetch-status, leaving routing mostly to inference.

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

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

With no annotations, the description must disclose side effects and return behavior itself. It only says the expression is discarded, which hints at ephemerality, but it never states whether a result is returned, how errors are handled, or whether the tool is safe/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 short and front-loaded: the core verb and object appear first, and the second sentence is not filler. It earns conciseness, though that brevity comes at the cost of essential detail.

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

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

For a 9-parameter tool with no annotations and no output schema, this description is far too thin. It omits the input-to-parameter mapping, return value, error behavior, and any relation to the sibling tools, making correct invocation practically impossible.

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 schema property has a description, none of them accepts the arithmetic expression the description references. The schema and description are fundamentally mismatched, so an agent cannot determine which parameter, if any, carries the expression to evaluate.

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

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

The description names a concrete operation ('Evaluate a+b style arithmetic'), so an agent may guess it is a calculator. But the schema exposes nine unrelated string parameters (ref, url, city, feed, host, json, path, zone, query) with no arithmetic-expression field, so the stated purpose cannot be mapped to any actual input.

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

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

No guidance is given on when to choose calc-eval over the many sibling tools, and no exclusions or alternatives are named. The only contextual hint is the vague 'Expression discarded,' which is not enough to define calling 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 provided, the description has to disclose behavioral context itself. It adds one useful privacy detail: 'Page content is not stored.' However, it does not say whether the tool makes a network request, follows redirects, or has side effects or rate limits, so the disclosure is meaningful but incomplete.

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

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

The description is two short sentences, with the core behavior in the first sentence and the privacy guarantee in the second. It is front-loaded, non-redundant, and every sentence earns its place.

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

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

The tool has seven optional parameters, no output schema, and no annotations, and the description does not clarify which parameters are relevant to 'a URL.' It also does not explain what the response structure is or how to handle combinations or omissions of parameters, leaving too much to inference.

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

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

The schema already documents every parameter with 100% coverage, so the baseline is 3. The description adds no additional meaning about how the seven optional parameters relate, which one is primary, or whether multiple parameters can be combined.

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 result: 'Return host, scheme, and HTTP status for a URL.' This is a specific verb and resource set, so an agent can infer the tool's job. It does not explicitly differentiate the tool from siblings like fetch-status or normalize-url, which also operate on URLs and statuses.

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, web-fetch, or normalize-url. The description implies a URL-oriented use case but gives no exclusions, prerequisites, or conditions that would help an agent choose confidently.

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 transparency burden. 'No identifiers are retained' is a useful privacy disclosure, but the description does not state whether the tool is read-only, whether it makes external calls, what side effects occur, or what the response looks like.

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

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

The description is very short and has no wasted words, with a clear two-sentence structure. However, the extreme brevity leads to under-specification: it is concise more because it says almost nothing than because it efficiently conveys the necessary 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?

This tool has 9 optional parameters, no output schema, and no annotations, so the description needs to explain how to invoke it correctly. It does not say whether exactly one parameter should be provided, what the classification output is, or how this tool relates to its sibling tools. An agent would struggle 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?

Schema description coverage is 100%, and each parameter has a terse but meaningful description (e.g., 'discarded after the check' or 'for a public weather hint'). The tool description itself adds no parameter-level meaning, but the schema already covers that ground.

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 verb and a subject: 'Show how this request is classified.' However, it never explains what 'classified' means, what classifications exist, or how the tool relates to its name 'compatibility.' It also does not distinguish this tool from the many sibling shape-checking and URL-checking tools.

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

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

There is no guidance about when to use this tool versus alternatives such as validate-json, normalize-url, domain-shape, or file-path-ok. The description provides no conditions, exclusions, or hints about which input should be 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?

No annotations are provided, so the description carries the full burden of disclosing behavior. It mentions the split action and the absence of WHOIS/ownership data, but does not explain output format, handling of invalid hostnames, case normalization, port stripping, or whether the result is a list, string, or count.

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. Both clauses earn their place: the action and the explicit limitation on ownership data.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, this description is too thin. It does not say what the tool returns, which parameter is actually required for the hostname split, or why the other inputs are accepted. An agent has to infer too much.

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's 'hostname' maps to the `host` parameter, but it adds no detail about parameter interaction. The presence of eight unrelated optional parameters is unexplained and could mislead an agent about how to invoke the 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 states a specific action and resource: split a hostname into labels. It also adds a meaningful negative scope (no WHOIS or ownership data), which helps distinguish it from ownership/resolution tools. It does not explicitly contrast with sibling shape tools, but the hostname focus is clear.

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 inferable: call this when you need to split a hostname into labels rather than look up ownership data. However, it names no alternatives or explicit when-not-to-use conditions, and the sibling tools include several URL/hostname-related utilities that an agent could confuse it with.

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 disclosure burden. It usefully states that the request is a HEAD to a public URL and that only the status is returned, implying no body download and no auth needed. It does not mention redirects, timeouts, or error behavior, but the core side-effect profile is clear enough for a simple network probe.

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

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

One short sentence with no filler; the key action, target, and output are front-loaded. The description is efficient, though terse.

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

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

The tool has 9 optional parameters, no annotations, no output schema, and many similar siblings. The description does not explain which parameters are relevant, whether the others are ignored, or how status results are represented, leaving significant gaps 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?

Schema description coverage is 100%, so the baseline is 3; the description adds no parameter-level meaning. It also creates mild ambiguity because the schema includes unrelated optional parameters like city, json, path, and zone, while the url parameter description mentions normalization/citation rather than HEAD status.

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

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

The description names an explicit HTTP verb (HEAD), a target (public URL), and an output (status only), so it is clear what the tool does. However, it does not explicitly differentiate itself from sibling tools such as web-fetch or browser-url-ok.

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

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

No when-to-use or when-not-to-use guidance is provided, and no alternatives are mentioned. The HEAD/status phrasing implies a lightweight liveness check, but an agent cannot tell from the description whether to choose this over browser-url-ok or web-fetch.

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 disclosure burden. It states that path is discarded, but it does not say what 'parse' returns, whether any network request is made, or how invalid Figma URLs are handled. Since there is no output schema, the agent is left without key behavioral details.

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

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

The description is only two short sentences with no filler, and the main purpose is front-loaded. 'Path discarded' is terse and slightly ambiguous, but it still earns its place as a useful behavioral note.

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, no annotations, and a large sibling set, the description is too sparse. It does not state the return value, which parameter to use, or failure behavior, and it leaves sibling differentiation mostly to the tool name.

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

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

The input schema has 100% description coverage, so the baseline is 3. The description adds the essential fact that the expected resource is a Figma file URL, which the generic `url` schema description does not convey. However, it does not clarify which of the nine optional parameters should actually be passed beyond implying `url` and saying `path` is discarded.

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

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

The description names a specific verb and resource: 'Parse a Figma file URL.' This clearly separates it from sibling shape-checkers like github-repo-shape, jira-key-shape, and domain-shape. The 'Path discarded' fragment is cryptic, but it does not obscure the core 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?

The phrase 'Parse a Figma file URL' implies the trigger for using this tool, but there is no explicit when-to-use or when-not-to-use guidance. It also does not compare against closely related siblings such as normalize-url or browser-url-ok, so an agent must infer the boundary from the tool name.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does state 'No disk access,' which is a useful non-side-effect guarantee, but it does not define what 'safe' means, what the return value looks like, or whether the path must exist. The wide schema also leaves uncertainty about which inputs are actually used.

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

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

Two sentences with no filler, and the key 'No disk access' constraint is front-loaded. This is appropriately concise for a simple checker, though it sacrifices detail needed for full clarity.

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

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

The tool has nine parameters, no output schema, and no annotations, leaving the description as the only context source. One sentence about path safety and no-disk-access is insufficient to explain the broad schema, expected return type, or safety criteria, so the definition is not complete enough for confident invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level detail beyond the schema; the 'path' property is already described as 'File path to check.' The many unrelated optional parameters could confuse an agent about which field to populate, and the description does not help disambiguate.

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

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

The description states a specific verb and resource: 'Check whether a path looks safe,' and it adds a distinguishing behavioral trait with 'No disk access.' This clearly differentiates it from sibling URL/title checkers, though the broad input schema with nine unrelated parameters slightly muddies the exact scope.

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

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

There is no guidance on when to use this tool versus alternatives like browser-url-ok or wiki-title-ok. The only contextual hint is 'No disk access,' which implies a lightweight validation use, but no explicit conditions, prerequisites, 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 present, so the description carries the full behavioral burden. It discloses the Open-Meteo backend but not whether the operation is read-only, which parameters are actually honored, how failures are reported, or that most schema fields appear to be discarded after 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 a single short sentence with no filler, and the core purpose and provider are front-loaded. Conciseness is excellent even though completeness is lacking.

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 required fields, no output schema, and no annotations, this description is insufficient. It does not identify which input to supply, what the return format is, or what happens when a place cannot be resolved.

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 geocoding context but never names the operative parameter, and the schema's 'city' text about a weather hint is not clearly aligned with the stated lat/long 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 names a concrete output (latitude and longitude) and a provider (Open-Meteo), which separates it from weather-hint and other sibling tools. However, it does not specify which of the nine optional schema fields supplies the 'place', and the schema's 'city' field is described as being for a public weather hint rather than coordinates.

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

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

There is no when-to-use guidance and no mention of alternatives. Siblings like weather-hint, timezone, and validate-json cover adjacent cases, but the description gives no basis for choosing geo-hint 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 behavioral burden, and 'parse' only implies a read-only operation. It does not disclose validation behavior, error handling, whether non-GitHub URLs are rejected, or that the schema's many parameters appear to be discarded after a shape check. The schema's URL description ('normalize or cite') also conflicts with the parse 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?

One short sentence is efficient and front-loaded, with no redundant phrases. However, it is so terse that it omits usage and behavioral details, so the economy comes at a cost.

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 annotations, no output schema, and a large sibling suite, a single parse statement is incomplete. The agent is left to infer that url is the meaningful input, what the return value looks like, and when to prefer this tool over normalizers and fetchers.

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; each parameter already has a description. The tool description adds the crucial fact that the GitHub URL yields owner/repo, but it never names the url parameter or clarifies that the other eight optional parameters are irrelevant to 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 states a specific verb ('parse'), a resource ('GitHub URL'), and the expected result ('owner and repo'), so the core purpose is unambiguous. It also separates this tool from sibling shape tools by naming GitHub, but it does not mention the shape-check behavior implied by the tool name and schema fields.

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

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

The description gives no explicit when-to-use or when-not-to-use guidance and names no alternatives. With sibling tools like normalize-url, web-fetch, and other *-shape tools, an agent has no basis for choosing this tool over them. The only implicit signal is the mention of GitHub URL, which is not enough.

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 transparency burden. It does disclose a behavioral trait: 'Titles discarded' indicates output excludes titles, and 'current' signals fresh data. It does not, however, mention whether the tool makes a network request, whether it is read-only, how failures are handled, or what the exact return format 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?

The description is extremely concise: two short sentences with no redundant wording. The main action is front-loaded, and 'Titles discarded' is a useful secondary note. 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 output schema and no annotations, yet the description provides no guidance on how to invoke it given the 9 optional, seemingly unrelated parameters. It is unclear whether any parameter is required, which parameter should be passed, or what exactly 'discarded' means for the input. An agent cannot confidently choose and populate the correct invocation from this description alone.

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

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

Schema coverage is 100%, so the baseline is 3 even though the description adds no parameter-level detail. The schema descriptions exist but are broad and seem misaligned with the tool's stated purpose; nothing in the description helps an agent choose among the 9 optional parameters. The description does not compensate for the ambiguity, so it stays 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 clearly states a specific operation: 'Count current Hacker News front-page stories.' This is a verb + resource combination that is easily distinguishable from the sibling tools, which focus on URL shape checks, validation, or fetching. The additional phrase 'Titles discarded' further clarifies that the tool returns a count, not story titles.

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: use this tool when the agent needs the number of current Hacker News front-page stories. However, there is no explicit when-not-to-use guidance or mention of alternatives, and the description does not address the 9 optional parameters or whether any input is actually 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?

No annotations are provided, so the description carries the full burden. It only states content (IANA timezone names) and does not disclose what the tool returns (e.g., a list or lookup), whether the list is exhaustive, how results are formatted, or whether any of the 9 parameters actually affect behavior.

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

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

The description is a single concise sentence with no filler or repetition. It front-loads the core content, though it sacrifices useful detail for brevity.

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

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

With 9 optional parameters, no output schema, and no annotations, the description is too thin to fully prepare an agent to invoke the tool correctly. The schema explains the parameters, but the description does not explain what output to expect or how these unrelated-looking parameters relate to IANA timezone names.

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 100% of parameters with individual descriptions, which gives the agent enough to understand each field at a basic level. The description itself adds no parameter meaning, so the baseline of 3 applies.

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

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

The description identifies the resource as 'Common IANA timezone names' and the intended context as 'clock calls', giving a clear sense of what the tool provides. However, it is a noun phrase rather than a verb+resource statement, and it does not explicitly distinguish this from sibling tools like timezone or utc-time.

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' implies the tool should be used when timezone names are needed alongside clock-related operations. It provides no explicit guidance about when not to use it or which sibling alternative to prefer, so the usage context is only implied.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It hints at read-only network access via 'public' and limits output to group counts, but it does not mention failure behavior, timeouts, redirects, authentication needs, or which parameters are actually used. This leaves important operational behavior undisclosed.

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 states the core action and the limited return value immediately, earning every word it uses.

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 parameter identifies the robots.txt URL or why the other parameters are present. An agent cannot reliably know what input to provide, so the definition is not complete enough 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?

Schema description coverage is 100%, so the baseline is 3 even though the tool description adds no parameter-specific meaning. The description does not map 'robots.txt' to any of the nine optional parameters, but the schema already documents each parameter individually.

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 states the output scope ('return group counts only'). This is clear enough to distinguish it from general fetch tools like web-fetch, though it does not explicitly name a sibling or explain how the target URL is supplied.

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

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

There is no guidance on when to use this tool versus alternatives such as web-fetch, fetch-status, or browser-url-ok. No exclusions, prerequisites, or routing conditions are provided, so an agent must infer when this tool is appropriate.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure. It reveals that the key is discarded after the check, which is useful, but it does not mention return values, error behavior, side effects, or whether other inputs are ignored. This is minimal behavior information.

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 the main action front-loaded. Both sentences carry meaningful information: the first states the tool's purpose and the second discloses data handling. There is no filler or redundancy.

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

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

For a tool with seven schema properties and no output schema, this description is inadequate for correct invocation. It fails to specify which input is the Jira key and what the shape-check result looks like, leaving an agent with insufficient information to select and call 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 description's central concept, the Jira key, is not mapped to any of the seven schema properties. The schema fields like ref, url, city, and json have their own descriptions, but none clearly represents the Jira issue key, so an agent cannot determine what to pass. The description adds no parameter-level guidance.

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

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

The description states a specific verb, 'Check', and a clear resource, 'Jira issue key shape', which distinguishes it from sibling shape tools like github-repo-shape or domain-shape. However, it does not explain which input parameter carries the Jira key, so purpose clarity is not complete.

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

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

There is no when-to-use guidance, no comparison with alternatives, and no prerequisites or exclusions. The single sentence only implies that this tool is for checking Jira issue key shapes, but it does not help an agent decide between this and 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?

With no annotations, the description carries the full burden, and it does disclose that the body is discarded and that the result is an HTTP status. However, it omits other useful behavioral context such as whether a live network request occurs, how redirects or errors are represented, and what the exact response shape 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?

The description is concise and front-loaded: two short sentences convey the purpose and the key body-discarded caveat without filler. The brevity is efficient, though it borders on under-specification given the broad 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?

For a tool with nine optional heterogeneous parameters, no output schema, and no annotations, the description is too thin. It does not explain how the tool applies to non-URL inputs, what a caller should pass for fields like city, zone, or json, or what a complete response looks like, leaving an agent under-informed 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?

Schema description coverage is 100%, so each parameter is individually documented and the baseline is 3. The tool description adds little parameter-level meaning beyond implying a URL is relevant, and it does not reconcile the other eight fields with the 'public library docs URL' framing.

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

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

The description states a specific action and resource: it provides an HTTP status for a public library docs URL and explicitly says the body is discarded. This makes the core purpose understandable, though the nine heterogeneous parameters in the schema are not reflected, leaving some ambiguity about the tool's full scope.

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

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

Usage is only implied: use this tool when you need just an HTTP status for a docs URL and do not need the body, since 'Body discarded' is the only exclusionary hint. It does not name alternatives like fetch-status, browser-url-ok, or web-fetch, so an agent gets no explicit when-or-when-not-to-use guidance.

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

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

No annotations are present, so the description carries the behavioral burden. It directly discloses that values are discarded, which is a meaningful behavioral trait beyond merely counting keys. It does not describe the return format or invalid-input behavior, but the core side-effect is clear.

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

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

Two short sentences, front-loaded with the action ('Count keys') and immediately followed by the critical caveat ('Values discarded'). Every sentence earns its place and there is no wasted text.

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 counting tool this is minimally viable, but with no annotations and no output schema the description omits the return type and what happens if no keys are present. The presence of many loosely related parameters also makes it less obvious that the input object itself is what gets counted.

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 and the schema already documents each parameter. The description's 'Values discarded' globally clarifies that parameter values are irrelevant to the count, which adds some meaning, but it does not explain which parameter holds the object to count or how the key count is derived.

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

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

The description names a specific action and resource: 'Count keys in a JSON object.' The second sentence, 'Values discarded,' adds the key boundary of what the tool does not do. This is clearly distinct from siblings like validate-json 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 implies the tool should be used when only the number of keys matters and values are irrelevant, but it never states when not to use it or names an alternative. There is no explicit steering toward or away from 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?

With no annotations, the description carries the burden of behavioral disclosure. It explicitly discloses a key behavior: query and fragment are discarded and only origin, host, and path are returned. It does not cover invalid-URL handling, but the core data-loss behavior is 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?

Two short sentences with no filler. The main output is stated first, and the important exclusion—query and fragment dropped—is front-loaded and concise.

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

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

Given a nine-parameter schema, no annotations, and no output schema, this description is under-specified. It does not identify which parameter to pass, does not clarify that other parameters are ignored, and provides no return-shape detail beyond field names.

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 guidance, such as directing the agent to the 'url' property or noting that the other eight optional parameters are irrelevant. The schema's own 'url' description carries that weight.

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

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

The description states a specific operation—return origin, host, and path for a URL—and clearly notes that query and fragment are dropped. This distinguishes it from sibling URL-related tools like web-fetch or browser-url-ok.

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

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

The dropped query/fragment clause implies this tool is not suitable when those parts must be preserved, but it does not explicitly name alternatives or state when to prefer this tool over siblings. Usage guidance is only 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 itself carries the behavioral burden. It does disclose one meaningful trait ('No browser is launched'), but it does not state whether the URL is fetched, whether the check is local only, what the return value is, or how the many 'discarded' parameters affect behavior.

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

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

The description is two short sentences with no filler, and the main purpose is front-loaded. Every word earns its place.

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

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

For a tool with nine optional parameters, no output schema, and no annotations, the description is too thin. An agent cannot tell which parameter to supply, what success/failure looks like, or how this relates to sibling URL tools.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the tool description adds no parameter-level detail. The schema thoroughly documents each of the nine optional parameters, so the description does not need to repeat them.

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

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

The description uses a specific verb ('Check') and resource ('whether a URL can be opened'), so the core action is identifiable. It is slightly ambiguous what 'can be opened' means (syntactic validity vs. reachability) and it does not clearly distinguish from siblings like fetch-status or browser-url-ok beyond the 'no browser' note.

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

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

The description gives no explicit when-to-use guidance or alternative tool names. 'No browser is launched' implies a lightweight check, but the agent is not told when to prefer this over browser-url-ok, fetch-status, or normalize-url.

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

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

With no annotations, the description carries the full behavioral burden. 'Query discarded' explicitly discloses the main side effect — the query is not retained after the call. For a stateless length-check tool, this is meaningful transparency, even if auth/network details are not relevant.

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

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

Two short sentences with the core action front-loaded and no filler. Every word earns its place, making it easy for an agent to parse quickly.

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

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

The tool is simple and the schema covers parameters, but there is no explicit statement of the return value (e.g., integer character count) and no guidance about ignoring the non-query fields. Without an output schema, the description should make the returned count more explicit.

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 fully documents all nine optional parameters. The description reinforces that the relevant input is a search query, but it does not add meaningful detail beyond the schema or clarify that the other eight fields are decoys/ignored.

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

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

The description states a specific action and resource: 'Count characters in a search query.' This clearly distinguishes it from sibling tools that normalize URLs, validate JSON, check file paths, or fetch statuses. The added 'Query discarded' also signals that this is not a search or storage 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?

Usage is implied rather than stated: an agent would call this tool when it needs the character length of a search query. There is no explicit when-to-use/when-not-to-use guidance, nor any mention of alternative sibling tools for similar tasks.

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, but it only says the tool is a short catalog. It does not disclose return format, whether parameters affect the result, or that the inputs are discarded as stated in the schema.

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

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

The description is a single short clause with no filler, and the subject is front-loaded. It sacrifices completeness for efficiency, but it is appropriately concise for such a brief statement.

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 seven optional-looking parameters and no output schema or annotations, the description explains none of the invocation context: what inputs should be supplied, what the return value contains, or how the catalog relates to the parameters. This is inadequate for an agent to use 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?

The input schema already describes all seven parameters in detail, so high schema coverage establishes a baseline of 3. The tool description itself adds nothing about parameters, and the relationship between the catalog and parameters like city or feed remains unexplained.

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

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

The description names the resource (catalog of common HTTP status codes) but uses no verb, so it is unclear whether the tool returns, lists, or looks up codes. It also does not distinguish itself from sibling tools such as fetch-status or web-fetch.

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

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

No guidance is given for when to use this tool or when to prefer a sibling such as fetch-status. There is no mention of scenarios, exclusions, or alternatives, so an agent must infer the trigger from the name alone.

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

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

With no annotations provided, the description carries the behavioral transparency burden. It discloses that the prompt is discarded, which signals no hidden dependence on input, and the input schema additionally marks many parameters as discarded. However, it does not describe side effects, what the template looks like, or whether any input has an effect at all.

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

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

The description is two short sentences with no filler. The core action is front-loaded, and the discard warning earns its place because it prevents an agent from expecting statefulness or a natural-language prompt effect.

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 the description omits what the returned three-step template actually contains. The input schema suggests varied purposes (normalization, weather hints, JSON validation, file paths), but the description says the prompt is discarded, creating a confusing picture. An agent would not know expected output or why certain parameters exist.

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 seven parameters with descriptions, so baseline is 3 even though the tool description itself adds no parameter meaning. The schema descriptions do provide semantics like 'discarded after the shape check' and 'HTTPS URL to normalize or cite,' but this is schema coverage, not description-added value.

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

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

The description names a specific verb and resource: 'Return a three-step thinking template.' This is clear and separable from the many shape-check and URL-normalization siblings. However, it does not explicitly distinguish itself from any sibling tool, and the note 'Prompt discarded' is ambiguous about what 'prompt' refers to relative to the input parameters.

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

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

There is no guidance on when to use this tool versus alternatives. The description gives no context, prerequisites, or exclusions. The only usage-like hint is 'Prompt discarded,' which is a behavioral warning rather than a when-to-use instruction.

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 burden of behavioral disclosure. It only states that the tool returns the current time, giving no detail about expected input validation, output format, network dependency, or error behavior. The description also does not address the notable mismatch between its mention of an IANA timezone and the schema, which lacks such a parameter.

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 that is front-loaded and easy to read. It wastes no words, but its brevity omits essential usage and parameter details, so it is concise yet incomplete.

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

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

Given no annotations, no output schema, and a schema with nine unrelated optional parameters, the description is far from sufficient. It does not explain how to provide the required IANA timezone, what the response looks like, or the role of the other parameters. The tool cannot be reliably selected or invoked based on this description alone.

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

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

Although schema description coverage is 100%, the schema contains no parameter for an IANA timezone, making the description's promise impossible to fulfill based on the provided input fields. The description does not clarify how to specify the timezone nor why the nine listed parameters such as 'ref' and 'query' are relevant. This is a critical semantic gap that prevents correct 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 'Current time in a named IANA timezone' clearly states the tool's function and distinguishes it from sibling tools like utc-time and iana-zones. However, it uses a noun phrase rather than an explicit verb and does not name its sibling alternatives. Overall the purpose is specific and understandable.

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

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

The description gives no guidance on when to use this tool versus alternatives such as utc-time or iana-zones. It neither states the conditions for selection nor excludes cases where another tool would be better. The 'named IANA timezone' phrasing implies a usage context, but no explicit guidance is provided.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure, but it only states the output value. It does not describe the timestamp format, whether parameters affect the result, or any side effects. The tool appears read-only, but nothing explicitly confirms this.

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 a bare noun phrase rather than a structured explanation. It is concise, yet for a tool exposing seven input parameters, the one-sentence description omits too much context to be considered 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 tool has no output schema, so the description should clarify return format, but it does not. It also fails to explain why the tool accepts seven unrelated input parameters when its sole purpose appears to be returning a current UTC timestamp.

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 parameters with descriptions, so schema coverage is high and the baseline is 3. The description itself adds no parameter semantics, but the schema already explains that values like 'ref' are 'discarded' and 'path' involves 'no disk access'.

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.' is essentially a restatement of the tool name 'utc-time', adding only the word 'current'. It lacks a verb and does not distinguish this tool from the sibling 'timezone', so the agent gets no clearer signal than the name itself.

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

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

There is no guidance on when to use this tool versus alternatives like 'timezone' or 'web-fetch'. The description gives no context for scenarios where UTC time is needed, and no mention of when it should not be used.

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 provided, so the description carries the behavioral disclosure burden. The statement 'The body is discarded' is a useful disclosure that the input is not stored or persisted. However, it does not explain what happens for invalid JSON or what result is returned, which is still relevant for a tool with no output schema.

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

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

The description is short, front-loaded with the purpose, and contains no filler. The second sentence about discarding the body adds meaningful behavioral context. The only minor flaw is that 'body' could be more precise as 'JSON text' or 'the `json` 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 a low-complexity validator, the core purpose and side-effect behavior are covered, and the schema fills in parameter details. However, the description does not explicitly point the agent to the `json` parameter among the seven schema properties, and with no output schema it leaves the return-value behavior unstated. The description is adequate but not complete.

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

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

The input schema has high coverage: all seven properties have descriptions, and the `json` parameter is explicitly described as 'JSON text to validate; discarded after the check.' The description itself adds no parameter-level meaning beyond this, so the baseline score of 3 applies.

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

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

The description states a specific verb and resource: 'Check whether a body is valid JSON.' This clearly identifies the core function and distinguishes it as a JSON-focused validator. It does not explicitly differentiate it from sibling validators like file-path-ok or domain-shape, and the term 'body' is slightly ambiguous, so it falls 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 this tool versus the many sibling validation tools. There are no usage conditions, exclusions, or alternative tool mentions. An agent must rely on the tool name and schema rather than the description to decide when validate-json is appropriate.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior, but it only mentions an external data source. It does not disclose whether the call is read-only, what side effects or network dependencies exist, rate limits, or what happens to the input values beyond the schema's discarded-after-call 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 description is a single front-loaded sentence with no filler. It states the core action and data source efficiently, earning its place without redundancy.

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 complex 9-parameter schema, no annotations, and no output schema, one sentence is far too thin. An agent cannot determine the expected return format, units, parameter selection rules, or why the schema contains many non-weather fields, so the description is not complete enough 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 coverage is 100%, so the schema already documents all nine parameters. The description adds the useful context that city is the weather input and Open-Meteo is the source, but it does not clarify how the many unrelated parameters relate to the weather call or which parameter is actually required, so the value added is moderate.

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 ('current temperature') and a specific resource ('city via Open-Meteo'), making the tool's core purpose immediately clear. It also differentiates from sibling tools like geo-hint by naming the data source.

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 weather-hint versus sibling tools, nor any mention of when not to use it. The description only states what the tool does, leaving the selection criteria entirely to inference.

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

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

No annotations are provided, so the description must carry the behavioral disclosure. It does disclose one important behavior—body discarded—but does not mention redirects, errors, timeouts, or side effects of fetching a remote URL. 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 repetition or filler; the key output behavior is front-loaded and the body-discard caveat is a useful follow-up. It is appropriately concise.

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

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

Given a 9-parameter schema with no annotations and no output schema, this description is not sufficient for an agent to reliably know which parameter to pass, how the extra parameters relate to the tool, or what the return shape will be beyond status/content type.

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

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

The input schema has 100% description coverage, so all nine parameters already have individual explanations. The description adds the URL-centric intent but does not explain the many apparently unrelated optional parameters, leaving the full selection of parameters 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 clearly states the tool returns HTTP status and content type for a public URL and explicitly says the body is discarded. This is specific enough to convey the core operation, though it does not differentiate web-fetch from sibling 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?

The description implies when the tool is appropriate: only for public URLs and only when the body is not needed. It does not explicitly name alternatives or state when-not-to-use relative to sibling tools, so guidance is implied rather than explicit.

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

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

The only behavioral disclosure is 'Title discarded after the call,' which addresses data retention but not other important behaviors such as network access, error handling, or how the title is resolved against Wikipedia. Because there are no annotations, the description carries the full burden and does not provide enough behavioral context for safe invocation.

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

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

The description is concise: two short sentences with no filler. The purpose is front-loaded and the 'discarded after the call' note adds a behavioral detail without wasting words. It is appropriately sized, though slightly under-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?

The output schema documents the return shape, but the description still fails to explain which input field carries the Wikipedia title and gives no context about expected inputs, examples, or failure behavior. Given the mismatched parameter set, an agent is unlikely to call this tool correctly without additional 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 input schema has descriptions for all seven parameters, but none of them is a 'title' parameter and none is explained as the Wikipedia title to check. The description does not map 'title' to any schema field, so an agent cannot determine which parameter to populate. Schema coverage is high, but the connection to the described purpose is missing.

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

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

The description states a clear purpose: 'Check whether a Wikipedia title exists.' This is a specific verb and resource, but it is not backed by the input schema, which exposes unrelated parameters like ref, city, feed, host, and json. The purpose is understandable on its own, but the schema mismatch makes the tool hard to identify as the correct one for a title 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 about when to use this tool versus alternatives like normalize-url, browser-url-ok, or citation. The description only says what the tool does, not when it should be preferred or avoided. No exclusions or alternative conditions are provided.

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