ISO country SS

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 task text is discarded and that the result can include remote MCP hops, but it does not mention side effects, network calls, authentication, or rate limits. For a read-oriented index lookup this is an acceptable but incomplete disclosure.

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 primary action and resource front-loaded and the outputs listed compactly. The final sentence about discarded task text earns its place by conveying an important behavioral constraint 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?

There is no output schema, so the description's list of return components is necessary and helpful. However, it does not explain how the six input parameters should be chosen or whether any are required, and it lacks guidance about the response shape beyond naming the artifacts, leaving the agent to infer the invocation pattern.

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 six parameters. The description adds no parameter-specific meaning beyond saying that task text is discarded, which aligns with the property descriptions; this is the baseline score rather than a penalty.

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 ('Find') and a concrete resource ('a public pay-per-call tool gateway (Monid)') and lists the expected return artifacts, so the purpose is unambiguous. It does not explicitly distinguish itself from sibling tools such as web-fetch, but the Monid-specific target makes confusion unlikely.

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 a clear context for when to call the tool: when the agent needs the Monid gateway's CLI setup, how-it-works, skill file, or remote MCP hops. It offers no explicit exclusions or alternatives, but for a niche lookup tool the stated purpose effectively communicates when it applies.

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, yet it only states that no browser is launched. It does not disclose whether a network request is made, whether the operation is read-only, what the response looks like, or how failures 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?

Two short sentences, no filler, and the key behavioral caveat 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 and no output schema or annotations, this is too thin. It leaves unclear which parameter to supply, what 'can be opened' means in practice, and what the return value is.

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

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

Schema description coverage is 100%, so the baseline of 3 applies. The tool description itself adds no parameter meaning, but each parameter already has a schema description; no further credit is warranted.

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

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

The description names a concrete action and object: 'Check whether a URL can be opened.' 'No browser is launched' usefully distinguishes this from browser-launching siblings such as playwright-url-ok. It loses a point because it is narrower than the nine-parameter schema and never acknowledges the non-URL inputs.

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 conditions, and no named alternatives. The no-browser note implies a lightweight check, but the agent must infer when to choose this over playwright-url-ok, normalize-url, or fetch-status.

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 disclosing behavior. It offers one signal ('Expression discarded') but does not explain what is discarded, whether a result is returned, how errors are handled, or whether the operation is read-only; 'Evaluate' and 'discarded' even pull in opposite directions.

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 fronts the purpose, but the second sentence is cryptic and adds confusion rather than clarity. This is under-specification, not 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?

With nine optional parameters, no output schema, and no annotations, the description is far too incomplete. It fails to specify the input parameter, the return value, or the behavior, so an agent cannot reliably select arguments or interpret 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?

Although schema description coverage is 100%, the description introduces an 'a+b style arithmetic' concept that maps to none of the nine parameters (ref, url, city, feed, host, json, path, zone, query). It gives the agent no help choosing which parameter holds the expression, and the schema does not contain 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 names a specific operation ('Evaluate a+b style arithmetic') that distinguishes it from sibling shape-check tools. However, the phrase 'Expression discarded' makes it unclear whether the tool returns a result, validates the expression, or simply discards it, and no arithmetic-expression parameter appears in the schema.

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

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

No usage context is given beyond the terse purpose. It does not state when to prefer calc-eval over alternatives, nor any exclusions, so an agent must guess when this tool is 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 explaining behavior, and it is only a noun phrase. It does not disclose side effects, read-only status, return behavior, or how inputs are treated. The schema hints that inputs are 'discarded' after checks, but the description itself reveals no behavioral traits.

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

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

The description is short and has no wasted words, but it is under-specified rather than concise in a useful way. A single noun clause cannot serve as an actionable tool definition for a tool with nine parameters and no annotations.

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 complex: nine optional parameters, no output schema, no annotations, and many related sibling tools. The description provides almost no context about what the tool does, what it returns, or how the parameters relate to the 'ISO 3166-1 record' purpose. This is far too incomplete for reliable selection and invocation.

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

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

Schema description coverage is 100%, so the input schema already documents all nine parameters. The description adds no parameter-level meaning, but the baseline of 3 applies because the schema is fully self-describing. The mismatch between the ISO record description and the generic parameters remains unexplained, but that is not a parameter-semantics failure.

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

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

The description says 'Public ISO 3166-1 record for SS' but never states an action. It identifies a resource (the SS country-code record) but does not say whether the tool retrieves, validates, returns, or checks anything. An agent cannot tell from this description what invoking the tool will accomplish.

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 the many sibling shape-check and validation tools. No conditions, prerequisites, or alternatives are mentioned, so an agent must infer usage entirely from the name and schema.

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

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

With no annotations provided, the description carries the transparency burden. It usefully discloses that page content is not stored, and it states the exact returned information. It does not cover network behavior, redirects, or failure modes, but the non-storage disclosure is meaningful and non-obvious.

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 and the behavioral qualifier second. Every sentence earns its place; there is no filler 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?

The description gives the core return values and a privacy-relevant behavior, which is helpful given there is no output schema. However, with 9 optional parameters and no required parameters, there is lingering ambiguity about how to invoke the tool correctly, and error behavior is not described.

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

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

All 9 parameters already have descriptions in the input schema, so the schema coverage is 100% and the baseline is 3. The description adds only 'for a URL' and does not clarify which optional parameter is primary or how the unrelated-looking parameters relate to the operation.

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

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

The description identifies a concrete operation: 'Return host, scheme, and HTTP status for a URL.' This is a specific verb and resource, and it is not a tautology of the tool name. It does not explicitly differentiate from sibling tools like fetch-status or normalize-url, 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?

The statement 'Page content is not stored' lightly implies use for lightweight metadata checks rather than full content retrieval. However, it does not explicitly say when to use citation versus fetch-status, web-fetch, or normalize-url, and it offers no 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?

With no annotations, the description carries the full burden of behavioral disclosure. It does add one useful privacy behavior ('No identifiers are retained'), but it does not explain what the tool does with the inputs, what kind of result is returned, or whether there are side effects or errors.

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 under-specified rather than efficiently complete. Both sentences are grammatically concise, yet they omit essential information about what the classification result looks like, so the brevity is not fully earned.

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

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

For a tool with 9 optional parameters, no output schema, no annotations, and many closely related siblings, this description is incomplete. An agent cannot tell what inputs to provide, what output to expect, or how the result should be interpreted.

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 9 parameters. The description itself adds no parameter-level meaning, but it does not need to compensate because each parameter already has a clear individual description.

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

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

The description states a verb and resource ('Show how this request is classified'), so it is not a tautology, but it is vague: it does not explain what classification labels or dimensions are produced, nor how this relates to the tool name 'compatibility'. It also does not distinguish this from the many sibling shape/ok/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?

There is no guidance about when to use this tool instead of the many similar siblings, such as domain-shape, file-path-ok, or validate-json. No context, prerequisites, or exclusions are given, so the agent must guess when this classification behavior is appropriate.

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

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

With no annotations, the description carries the disclosure burden; it does add a useful behavioral boundary ('without WHOIS or ownership data') and implies a non-destructive text operation. It does not, however, disclose that non-host parameters are discarded or describe the result shape. The discard behavior is only recoverable from parameter descriptions, not 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 one tightly scoped sentence with a clear verb and no filler. It could be improved by front-loading the return format, but it is efficient for what it states.

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 annotation, so the description should explain the result format and invalid-input behavior; it only says 'split into labels.' The definition also does not account for the nine-parameter schema, leaving an agent guessing which parameters are meaningful and what a 'shape check' returns.

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 with no parameter detail in the tool description. The word 'hostname' aligns with the host parameter, but the description adds no meaning beyond what the input schema already provides.

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: 'Split a hostname into labels' and explicitly excludes a related concern ('without WHOIS or ownership data'). This is specific enough to distinguish domain-shape from siblings like normalize-url, jira-key-shape, or wiki-title-ok without opening their schemas.

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

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

The description implies usage when you need hostname labels and not ownership data, but it never names an alternative ('use X instead') or states a condition like 'for full URL validation use normalize-url'. Sibling tools exist, so this is a gap, but the negative scope provides some routing guidance.

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

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

With no annotations, the description carries the full transparency burden and it does disclose the HTTP verb, the public scope, and that it returns no body, only status. This makes the operation's read-only, non-destructive character clear, though it does not cover edge behavior such as redirects or error handling.

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

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

One short, front-loaded sentence contains the essential action, target, and output restriction. Every word earns its place, and there is no filler.

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

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

Despite a simple core operation, the tool exposes nine optional parameters and no output schema, yet the description gives no guidance on which parameter to provide or how the 'status only' result is represented. Without more context, an agent may be uncertain how to invoke the tool correctly for non-URL inputs.

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 100obviously, so the schema already documents every parameter. The description adds no additional parameter meaning beyond the most salient 'url' input, which keeps it 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 an unambiguous action verb ('HEAD'), the exact resource ('a public URL'), and the result ('return status only'). This clearly distinguishes it from content-fetching siblings like web-fetch and from browser-based checks like 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 operation itself implies a use case: lightweight status-only checking without retrieving content. However, the description does not explicitly say 'use this instead of web-fetch when you need only the HTTP status' or name any alternative, so guidance remains 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?

No annotations are present, so the description must carry the behavioral disclosure burden. It discloses only that the path is discarded, but says nothing about whether the tool validates, normalizes, fetches, or returns a result, or whether it has side effects.

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-loads the core action in the first sentence. The second sentence is terse and relevant, but its ambiguity slightly weakens the overall structure.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, the description is incomplete. It does not say which parameter to populate, what the tool returns, or what qualifies as a valid Figma URL shape.

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 sets a baseline of 3. The description does not explicitly map the Figma URL to the `url` parameter, leaving nine optional properties with no required parameters, though the schema descriptions are individually clear.

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

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

The description states a specific verb and resource: 'Parse a Figma file URL', which distinguishes it from sibling shape tools like github-repo-shape and jira-key-shape. 'Path discarded' adds a scope note but is ambiguous about whether it refers to the URL path or the `path` parameter.

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

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

No guidance is given about when to use this tool versus alternatives such as normalize-url or browser-url-ok. There are no exclusions, no context, and no mention of 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 present, the description carries the behavioral disclosure burden. It does add one meaningful trait: 'No disk access,' which tells the agent the tool won't touch the filesystem. However, it does not disclose the return format, the meaning of 'ok', whether network access is also avoided, or how the extra schema fields (url, city, feed, etc.) are handled.

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

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

The description is two short sentences with no filler. It front-loads the core purpose and immediately adds the critical no-I/O behavioral constraint. 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 appears simple but the schema includes many apparently unrelated parameters (url, city, feed, host, json, ref), and the description does not explain their role or the relationship to path checking. With no output schema and no return-type information, the agent is left guessing what a successful check returns and what 'looks safe' actually validates.

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 every parameter, including 'path' and 'access', so schema coverage is high. The description itself adds no parameter-level meaning, but the schema already documents each field and notes that several fields are discarded after the check. This meets the baseline for well-described schemas.

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.' This is clear and distinct from sibling URL/web tools, and the addition of 'No disk access' clarifies it is a pure shape/safety validation. However, it does not define what 'safe' means (e.g., syntactic validity, path traversal prevention) or what output the agent should expect.

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 use this tool versus alternatives like browser-url-ok, playwright-url-ok, or normalize-url. 'No disk access' only implies this tool is for non-I/O checks, but it never states exclusions or recommends another tool for actual filesystem verification or URL validation.

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 reveals an Open-Meteo dependency but says nothing about network requirements, rate limits, error behavior, or the fact that many input fields such as ref, url, json, path, and query are described in the schema as being discarded after validation rather than contributing to the location lookup.

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. Every word contributes to the core purpose and identifies the external service.

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 too sparse. An agent cannot determine which parameter is required for a location lookup, what the returned coordinates look like, or which inputs are ignored, so the definition 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 description coverage is 100%, so the schema already documents all nine parameters. The description adds no explicit mapping between the 'place' concept and a specific parameter, leaving ambiguity about which field to populate, but it does not need to repeat the schema's parameter details.

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 returns latitude and longitude for a place and names the external source (Open-Meteo), which is specific and not a tautology. It does not specify which parameter provides the place, and it does not explicitly differentiate itself from weather-hint or similar lookups, but the core purpose 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?

There is no guidance about when to use geo-hint versus sibling tools such as weather-hint, timezone, or normalize-url. The description only implies coordinate lookup, with no alternatives, exclusions, or prerequisites.

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, and it only promises a parse operation. It does not reveal the return shape, error behavior for non-GitHub URLs, or that several accepted parameters are discarded after the call. The 'discarded' details live only in the schema, not in the description.

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

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

A single sentence with no filler, and the core action is front-loaded. It is appropriately brief, though slightly under-specified given the complexity of the 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?

No annotations, no output schema, 9 parameters with none required, and a description that only states the core parse. The agent is not told which parameter to populate, what the result looks like, or whether irrelevant parameters are ignored. This is not 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?

All 9 parameters have schema descriptions, so the baseline is 3. The description adds the useful clarification that `url` should be a GitHub URL and that owner/repo are the extracted result, which the generic url schema description misses. However, it does not explain which of the other 8 parameters are relevant or required, so it does not exceed 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?

States a specific verb ('parse') and resource ('owner and repo' from 'a GitHub URL'), so an agent immediately knows the tool's function. This clearly distinguishes it from sibling shape tools like figma-url-shape or jira-key-shape. No vague or tautological language.

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 obvious trigger—when a GitHub URL needs to be reduced to owner/repo—but it never explicitly says 'use this when...' nor contrasts it with alternatives like normalize-url or web-fetch. There are no prerequisites or exclusions stated, so guidance is inferred 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?

With no annotations, the description carries the behavioral burden. It does disclose that titles are discarded, suggesting the output is a count rather than story content, and 'current' implies a live snapshot. However, it does not state the return format, whether network access is required, how errors behave, or that no parameters are needed, leaving transparency 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 very short—two terse sentences—and front-loads the core verb and object. Every phrase earns its place; 'Titles discarded' clarifies scope without wasted words.

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

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

For a tool with no output schema and no annotations, the description leaves key context unresolved: whether to call with zero arguments, how optional parameters like 'city' or 'json' relate (if at all) to counting HN stories, and what exact result the agent will receive. The 9-parameter schema makes the description too thin to fully guide invocation, even though the core purpose is clear.

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 of the 9 optional parameters has its own description, so the schema already documents parameter-level meaning. The tool description adds no mapping between these parameters and the HN count behavior, although 'Titles discarded' echoes the feed parameter's phrasing. Baseline 3 is appropriate because high schema coverage means the description need not duplicate parameter docs.

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 resource ('current Hacker News front-page stories'), so an agent can clearly grasp what the tool does. It does not explicitly differentiate from siblings, but no sibling name covers this exact HN story-counting purpose. 'Titles discarded' adds a useful scope qualifier, though it is terse.

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

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

No guidance is provided about when to use this tool versus alternatives like web-fetch or fetch-status. The description implies a use case but includes no exclusions, preconditions, or references to sibling tools. An agent must infer both selection and invocation behavior from the name and one-line description.

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 bears the full behavioral burden. It does not disclose side effects, return format, or filtering behavior, and the 9 input parameters describe unrelated-looking operations such as URL normalization, JSON validation, and file-path checks that clash with the timezone-purpose description. An agent cannot predict what invoking this tool will actually do.

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, which is structurally concise. But it is under-specified, more like a tagline than a usable tool description, so it does not earn a higher score.

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

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

With 9 parameters, no annotations, no output schema, and a large sibling set, the description is critically incomplete. It fails to explain return values, parameter roles, or when to call this tool, leaving an agent without enough information 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 description coverage is 100%, so the baseline is 3; each parameter already has a description. However, the tool description adds no mapping between those parameters and the claimed IANA timezone purpose, and no parameter obviously selects a timezone.

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

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

The description "Common IANA timezone names for clock calls" identifies a resource and a general domain but uses no verb and never says what the tool does with those names. It largely restates the tool name and does not distinguish it from sibling time/date tools such as 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?

There is no when-to-use guidance, no exclusions, and no mention of alternatives. "For clock calls" hints at a context but does not tell an agent when to prefer this tool over the many time, zone, and weather 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?

There are no annotations, so the description carries the full burden. It does disclose that the tool fetches a public resource and returns only counts, implying a read-only network operation. However, it does not mention failure modes, timeout behavior, or what happens when the robots.txt is missing or invalid.

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

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

A single sentence, front-loaded with the action and resource, with no filler. Every word contributes to the core purpose.

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

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

Despite being concise, the description is insufficient for correct invocation: it has 9 optional params, no output schema, no annotations, and no mapping from description to parameters. The agent is left guessing which field to populate and what 'group counts' means in practice.

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%, but the parameter descriptions are generic and mostly irrelevant to robots.txt (e.g., 'City name for a public weather hint,' 'JSON text to validate'). The description never specifies which parameter supplies the robots.txt URL, and with zero required parameters, an agent cannot confidently know how to invoke the tool 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 uses a specific verb ('Fetch') and a specific resource ('public robots.txt') and narrows the output to 'group counts only.' This clearly distinguishes it from sibling tools like web-fetch, fetch-status, and normalize-url, which serve different purposes.

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 is for retrieving robots.txt group counts, but it gives no explicit guidance on when to prefer it over alternatives or which sibling tools it complements. There is no mention of exclusions or conditions like 'use this when you only need counts and not the full robots.txt.'

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 for behavioral disclosure. 'Key discarded' adds a small hint that the input is not retained, but the description does not explain return values, whether the check returns a boolean or throws, what constitutes a valid shape, or any side effects. This is insufficient for a validation tool without an 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 very short and front-loaded, with the core purpose in the first sentence. The second sentence attempts to add a behavioral note. It is concise with no fluff, though 'Key discarded' is cryptic and could have been clearer.

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 required parameters, no output schema, and no annotations. The description does not explain how to supply the Jira key, what the check returns, or what shape is considered valid. Given the complexity and the mismatch between the description and schema, this is critically incomplete.

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

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

The schema has 100% description coverage, but its nine properties (ref, url, city, feed, host, json, path, zone, query) are unrelated to a Jira issue key, and there is no 'key' parameter at all. The tool description does not clarify which parameter should receive the Jira key, making it impossible to invoke correctly based on the given information. The high schema coverage does not rescue this mismatch.

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

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

The description names a specific verb ('check'), a specific resource ('Jira issue key shape'), and implies a validation function. It also distinguishes this tool from sibling shape-checkers like github-repo-shape and domain-shape. However, it does not explicitly contrast it with those siblings, so it stops short of a 5.

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

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

The description provides no guidance about when to use this tool versus alternatives. It does not mention when not to use it, such as for URLs, GitHub repos, domains, or other non-Jira inputs. The sibling tool names imply a broader shape-checking family, but the description itself leaves usage inference entirely to the agent.

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 a key behavior (HTTP status returned, body discarded), but it does not explain how the surplus parameters are treated, whether redirects are followed, or what error/timeout behavior to expect.

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 core behavior 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?

The description is too sparse for a tool with nine optional parameters, no required fields, no output schema, and no annotations. An agent cannot tell how to construct a valid invocation or which parameter matters, so the definition is not complete enough for correct use.

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

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

All nine parameters have schema descriptions, so the baseline is 3, but the description fails to resolve which parameter is the URL to check. The `url` schema description ('HTTPS URL to normalize or cite') conflicts with the tool's stated status-checking purpose, and the other parameters are marked as discarded for unrelated checks, adding confusion.

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 returns an HTTP status for a public library docs URL, and notes the body is discarded. This is more informative than a tautology and gives a basic sense of what the tool returns, though it does not differentiate from sibling status tools like fetch-status.

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

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

No when-to-use or alternative guidance is provided. The phrase 'Body discarded' hints that the tool is not for content retrieval, but it never names siblings or states conditions for choosing this over fetch-status, 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?

The 'Values discarded' phrase discloses that the tool does not retain or return the object's values, which is useful given no annotations are present. Still, it does not describe the return format, error behavior, or side effects, so full transparency is lacking.

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

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

The description is extremely short and front-loaded, with two sentences that each earn their place. However, for a tool with nine optional parameters, this brevity leaves important invocation details unsaid.

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

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

The tool has a complex, multi-parameter schema, no output schema, and no annotations, so the description alone must carry the burden. Seven words are insufficient to clarify which input to pass, how the count is returned, and how this relates to the sibling tools.

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

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

Schema description coverage is 100%, so the baseline applies: each parameter is already documented. The description adds the concept of counting JSON keys but does not explicitly direct the agent to the 'json' parameter or clarify why nine unrelated parameters are present.

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

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

The description states a specific operation—Counting keys in a JSON object—and notes that values are discarded, which distinguishes it from validation and shape-checking siblings. However, it does not explain how the nine optional schema parameters map to this operation, leaving some ambiguity.

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

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

No guidance is given about when to use this tool instead of siblings like validate-json or the various shape check tools. There are no usage conditions, no exclusions, and no mention of which parameter supplies the JSON object.

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 query and fragment are dropped, which is a useful transformation behavior. However, with no annotations, it does not specify the output structure, error behavior, or the fact that the other eight schema parameters are effectively ignored. The schema's 'discarded' notes partially cover this, but the description alone 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 the core purpose and key drop behavior front-loaded. There is no filler, repetition, or unnecessary 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?

With nine optional parameters and no output schema, the description is under-specified. It does not explain why the other parameters exist, how the return value is structured, or whether the tool only acts on the 'url' field. This leaves the agent uncertain when calling the tool with multiple 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 the baseline is 3. The description adds meaning for the url parameter by saying normalization returns origin, host, and path, but it does not explain the other parameters beyond what the schema already states.

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: 'Return origin, host, and path for a URL. Query and fragment are dropped.' This clearly states what the tool does and distinguishes it from sibling tools like browser-url-ok or figma-url-shape, which focus on validation or shape checks.

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

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

The description gives no guidance about when to use this tool versus alternatives. It does not mention preferred use cases, conditions, or exclusions, so the agent must infer from the tool name and sibling context.

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

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

With no annotations, the description carries the disclosure burden. It does add useful behavioral context: the operation returns information and notably 'Query text discarded', signaling that search text is ignored. But it does not state whether any inputs have side effects, whether credentials are needed, or describe the output shape/provenance, so disclosure is partial.

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

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

The description is three short sentences with no filler and the primary purpose is front-loaded in the first sentence. It earns conciseness points, though the final sentence about query text is an awkward appendage and could have been folded into the behavior 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 only 9 optional parameters and no output schema, the description leaves significant ambiguity: what 'living people-search index' means, which parameters are meaningful (many look unrelated), what the returned CLI setup/docs/API/hops look like, and why query text is discarded. The tool is simple in type but the definition does not make it self-sufficient for an agent to invoke correctly.

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

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

Schema description coverage is 100%, so the input schema already documents each parameter and the baseline is 3. The description adds little beyond reasserting that query text is discarded; it does not explain the relationship between the 9 unrelated optional parameters and the returned index, but it does not need to compensate for missing schema descriptions.

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

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

The description names a concrete resource ('living people-search index (Ploid)') and states what the tool returns ('CLI setup, docs, API, and remote MCP hops'), so an agent can tell roughly what it does. However, it does not differentiate it from sibling index/catalog tools such as agent-tool-index or lib-docs-hint, and 'living'/'Ploid' are 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 phrasing 'Find a living people-search index' implies the intended use, but the description gives no explicit when-to-use guidance, no exclusions, and no alternatives. An agent must infer that this is the right tool for retrieving Ploid setup/docs and not another catalog or shape-check sibling.

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. 'No browser is launched' is a genuinely useful trait that corrects assumptions about Playwright usage, but the description does not explain what 'can be opened' actually means, whether a network request is made, whether there are rate limits or side effects, or what result is returned. Key behaviors remain opaque.

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

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

Two short sentences, each earning their place: the first states the action and the second states the key behavioral constraint. The description is front-loaded, free of filler, and easy to parse. Any weakness is in completeness rather than conciseness.

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

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

With nine heterogeneous parameters, no annotations, and no output schema, a one-line description is insufficient. It does not specify the return value, success/failure criteria, whether network access is involved, or how non-URL parameters like city, json, and path relate to the stated URL-checking task. An agent lacks important context 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 tool description itself adds no parameter-level meaning and does not mention any of the nine parameters. However, the input schema provides descriptions for every parameter, giving high schema coverage, so the baseline of 3 applies. Some schema descriptions are odd or template-like (e.g., 'for {{name}} to cite'), but that is not the description's fault.

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 whether a URL can be opened') and adds a useful differentiator: 'No browser is launched.' This helps distinguish it from browser-based URL tools like browser-url-ok. However, the schema accepts many non-URL parameters such as city, json, path, and search, so the stated purpose does not fully cover the tool's actual input surface.

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 explicit guidance on when to use this tool instead of alternatives. The only hint is 'No browser is launched,' which implies a lightweight check, but sibling tools like browser-url-ok and web-fetch are never mentioned or contrasted. An agent must infer the appropriate usage context.

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

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

The description discloses one useful behavioral trait: 'Query discarded,' indicating the search text is not retained. However, with no annotations, it does not cover other important details like return format, error behavior, or what happens when multiple non-query parameters are provided.

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 core action is front-loaded and the discard note is relevant. It could add a tiny bit more context without becoming verbose.

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

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

The tool accepts 9 optional parameters and has no output schema or annotations, yet the description only mentions a generic 'search query.' It does not state the return type, the behavior when multiple parameters are provided, or which parameters are actually needed, making it incomplete for reliable invocation.

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

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

Schema description coverage is 100%, so all 9 parameters are already documented in the schema. The description adds no new parameter-level meaning beyond implying the relevant parameter is `query`, so the baseline score of 3 is appropriate.

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

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

States a specific operation ('Count characters') on a 'search query,' which aligns with the tool name and distinguishes it from URL/JSON/path validators among siblings. However, it does not explicitly identify the `query` property among the 9 schema parameters, leaving slight ambiguity.

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

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

No guidance on when to use this tool versus alternatives such as validate-json, normalize-url, or file-path-ok. The discard note is behavioral rather than selectional, so an agent gets no help choosing 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 provided, the description carries the full burden of behavioral disclosure, but it only says the tool is a 'short catalog.' It does not state whether this tool reads, mutates, validates, or returns data, nor does it disclose side effects, permissions, or output behavior. This leaves the agent with almost no behavioral 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 a single short sentence with no padding, but it is under-specified: the word 'Short' adds little value, and there is no structure such as a leading action or usage cue. It is concise but at the expense of useful content.

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

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

The tool has 9 parameters, no output schema, and no annotations, yet the description only names a domain. It fails to explain what the tool does with the parameters, what it returns, or how it should be invoked. Far more context is needed for an agent to use this correctly.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters. The description adds no parameter-level meaning and does not explain how parameters like ref, city, or json relate to an HTTP status code catalog, so the baseline score of 3 is appropriate.

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

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

The description identifies the resource as a catalog of common HTTP status codes, so an agent can infer the domain. However, it lacks a verb or action—it does not say whether the tool returns, lists, or validates status codes—and it does nothing to distinguish itself from siblings 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?

There is no guidance about when to use this tool versus its siblings. No alternatives are named, no exclusions are given, and no context is provided that would help an agent choose status-catalog over fetch-status or other status-related tools.

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

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

With no annotations present, the description carries the transparency burden, and it does disclose the key side-effect-like trait: the prompt is discarded. This addresses privacy and statelessness concerns and goes beyond what the schema alone would reveal. It stops short of explicitly saying all supplied values are ignored, but the schema field descriptions reinforce the discard 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 definition is two terse sentences with no filler, one for the return value and one for the discard behavior. It front-loads the main purpose and keeps the salient transparency note right behind it.

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 stateless template-return tool the description is mostly adequate, but the seven-parameter schema makes it unclear whether any parameter affects the returned template or whether all are decoys; 'Prompt discarded' is narrower than 'all inputs ignored'. An explicit 'call with no meaningful arguments' note or an example would remove the remaining uncertainty, especially since there is no output schema to clarify the template.

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 rich, 100% coverage descriptions for every parameter individually, so the description need not add parameter-level detail. The description contributes only a generic discard signal, not syntax or format guidance; the schema already carries that load.

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

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

The description states a specific action and deliverable: it returns a three-step thinking template, and it adds the important behavioral qualifier that the prompt is discarded. It does not explicitly differentiate from sibling tools, but no sibling offers an identical template-return behavior, so the purpose is unambiguous.

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

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

There is no guidance on when to call this tool versus any alternative; the only implied context is the tool's name and the fact that it returns a template. No exclusions, prerequisites, or fallback conditions are mentioned, so the burden is left entirely to the caller.

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. 'Current time' reasonably implies a read-only, non-mutating operation, but the description does not disclose how invalid timezone names are handled, what output format is returned, or whether the time comes from a live system clock. This is minimal but not absent.

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

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

The description is a single, compact phrase with no filler words, and the key scoping detail ('named IANA timezone') 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?

The tool cannot be correctly invoked from the information provided: the description says a named IANA timezone is needed, but the schema has no timezone parameter, no example input is offered, and there is no output schema describing the result. The mismatch between purpose and parameters is a fatal gap in completeness.

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

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

The input schema lists parameters such as ref, url, city, feed, host, json, and path, none of which is an IANA timezone identifier. The tool description refers to a 'named IANA timezone' but provides no mapping to any schema property, and no parameter is required. The schema descriptions are detailed but unrelated to the tool's stated purpose, so an agent cannot determine how to supply the timezone.

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's resource and scope: it returns the current time for a named IANA timezone. This is specific and clearly differentiates the tool from siblings like utc-time and iana-zones, though it does not explicitly name them. The absence of a verb is minor because the intent is unambiguous.

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

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

No guidance is provided about when to use this tool instead of utc-time or iana-zones, and no edge cases or validation conditions are mentioned. The intended usage is only implied by the purpose, with no explicit when-to-use or when-not-to-use 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 available, the description carries the full behavioral disclosure burden. It does not mention that the supplied parameters such as `ref`, `url`, `city`, and `json` are all discarded, nor does it describe the output format or confirm the call has no side effects.

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 four words, front-loaded, and contains no filler. Every word contributes to the meaning, and the structure is as efficient as possible for a trivial timestamp 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?

For a stateless read-only timestamp tool, the short description is mostly adequate, but it leaves gaps: the return format is unspecified and the purpose of the unrelated optional parameters is unexplained in the description. An agent might still be uncertain whether passing `url` or `city` will affect the result, even though the schema says they are discarded.

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

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

The input schema already documents each parameter, including the fact that values are discarded after the check or call, so schema coverage is high. The description itself adds no meaning to the parameters, and the baseline of 3 is therefore appropriate.

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

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

The description states the tool returns the current UTC timestamp, which is a clear function. It does not explicitly distinguish this from sibling time-related tools like `timezone` or `iana-zones`, but the noun phrase is specific and not tautological.

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

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

There is no guidance about when to use this tool versus alternatives such as `timezone` or `iana-zones`. The intended usage is only implied by the tool name and the short description; no exclusions or routing hints 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses that the body is discarded, which is useful, but it does not state the return value, whether validation errors are explained, or any additional side effects. This leaves behavior under-specified for an agent that needs to interpret the result.

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

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

Two short sentences with no filler; the primary behavior is front-loaded and the discard note is valuable. 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 schema is surprisingly broad with eight parameters and no output schema, yet the description gives no context for the unrelated-looking parameters and no explanation of what the caller should pass as the 'body.' An agent cannot confidently predict the response format or which parameter is the actual JSON input without deeper inspection.

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

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

The input schema already provides descriptions for all parameters, including 'json: JSON text to validate; discarded after the check,' so schema coverage is effectively complete. The description adds no parameter-level meaning beyond the schema and does not clarify why the other parameters like ref, url, city, feed, host, and path exist. The baseline 3 is appropriate.

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

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

The description states a specific verb ('check') and resource ('body') with a clear JSON focus, which distinguishes it from sibling shape/validation tools. It does not explicitly connect 'body' to the `json` parameter, so an agent must inspect the schema to map the description to the 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?

There is no guidance about when to use this tool versus alternatives such as domain-shape, file-path-ok, or wiki-title-ok. The description only implies the use case through the phrase 'valid JSON,' which is already obvious 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?

There are no annotations, so the description must explain behavioral traits such as network dependency, side effects, and return behavior. It only names the data source and purpose; it does not disclose that the tool likely makes a live Open-Meteo call, ignores most parameters, or what response format/units to expect.

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

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

The description is a single, front-loaded sentence with no filler. It is appropriately concise for stating the core purpose, though the complexity of the parameter schema could justify a bit more clarification.

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

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

With no output schema and no annotations, the description is incomplete for a tool that has 9 unrelated optional parameters. It does not explain why so many other parameters exist, whether they are ignored, or what the tool returns beyond a vague 'current temperature'.

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 input schema already documents all 9 parameters. The description adds only that 'city' is the relevant input for the weather query, which is minimal but acceptable given the schema coverage 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 identifies the tool's purpose: returning current temperature for a city via Open-Meteo. It is distinct from sibling hint tools like geo-hint or lib-docs-hint, though it lacks an explicit verb such as 'get' or 'retrieve'.

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 prefer this tool over alternatives, nor does it state exclusions or the fact that most of the 9 parameters are irrelevant. The intended usage is only implied by the mention of 'city' and Open-Meteo.

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. 'Body discarded' is a useful behavioral disclosure, and the intended output (status and content type) is clear. However, it does not disclose network side effects, error behavior, redirects, or the fact that many schema parameters appear irrelevant to the fetch.

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 core purpose and ending with a critical behavioral caveat. There is no redundant wording; 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 annotations, and no output schema, the description is too thin. It never explains which parameter to supply, what happens when URL is absent, or the exact shape of the returned status/content-type result. The contrast with the many sibling shape-check tools makes this gap more consequential.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds no parameter-level meaning and does not clarify that the URL is the primary meaningful input while the other eight parameters are mostly discarded. Baseline 3 is appropriate because the schema carries the load.

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

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

The description clearly identifies the tool's resource (public URL) and what it reports (HTTP status and content type), and the note 'Body discarded' prevents a common misunderstanding. It does not explicitly distinguish itself from siblings like fetch-status or browser-url-ok, so it stops short of full sibling differentiation.

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

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

The phrase 'for a public URL' gives a minimal scope hint, but there is no guidance about when to choose web-fetch over fetch-status, browser-url-ok, or normalize-url. No when-not-to-use conditions or alternative tools are mentioned.

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

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

The description adds a behavioral note—'Title discarded after the call'—which informs the agent that the input is not retained. Since no annotations are provided, this modest disclosure is useful, but it omits other behaviors such as whether network access is required or what happens on invalid input.

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

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

The description is concise and front-loaded, with no wasted words. Both sentences earn their place, though the second sentence is a minor detail rather than essential usage information.

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

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

The description is far from complete for an effective tool call. It does not specify what the tool returns (e.g., a boolean), fails to align with the input schema, and provides no usage context or fallback guidance. The mismatch between described functionality and schema makes the tool effectively unusable 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 description references a 'title' parameter, but the input schema contains no such property—instead offering ref, url, city, feed, host, json, and path, none of which clearly map to a Wikipedia title. This creates a severe mismatch, and the description does nothing to resolve which parameter should carry the title, leaving the agent unable to invoke the tool 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 clearly states a specific action—checking whether a Wikipedia title exists—with a specific resource (Wikipedia title). However, it does not differentiate this tool from siblings like browser-url-ok or file-path-ok, which also perform existence or shape checks, so it earns a 4 rather than 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?

The description provides no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or context. An agent has to infer entirely from the tool name and sibling list.

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