ISO country CM

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

With no annotations available, the description carries the behavioral disclosure burden. It does disclose a meaningful privacy behavior ('Task text discarded') and frames the operation as a read/find action by saying 'Returns'. However, it does not state whether any remote call is made, mention authentication or rate limits, or describe what happens when no matching gateway is found.

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 that packs in the action, target, return items, and a privacy note without wasted words. Every phrase earns its place and the most important scoping detail ('Task text discarded') is clearly separated at the end.

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

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

Given 9 optional parameters, no output schema, and no annotations, the description is insufficient for confident invocation. It does not explain parameter selection, whether to pass one or many parameters, what the returned artifacts look like, or how 'shape check' relates to the described outputs. An agent has no way to know what to pass 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 description coverage is 100%, so the baseline is 3. The description does not explain why there are 9 unrelated optional parameters or how they relate to the stated purpose of finding a gateway. The schema descriptions individually mention 'shape check' behavior, but the main description never bridges that to the tool's overall function, so it adds no extra parameter-level meaning.

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 ('Find') and names a concrete resource ('public pay-per-call tool gateway (Monid)'), then enumerates the distinct return payloads: CLI setup, how-it-works, skill file, and remote MCP hops. This clearly separates it from the sibling tools, none of which claim to return gateway setup or MCP hop information.

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 usage context is implied: an agent would call this when it needs a Monid gateway's setup and remote MCP hops. However, there is no explicit guidance about when to prefer this tool over a sibling, nor any 'do not use' conditions. The description stops short of giving selection criteria.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose one important behavior: no browser is launched, which corrects a likely misreading of the tool name. However, it leaves unclear whether 'can be opened' means an HTTP request, a syntax check, or a reachability probe, and whether side effects like network activity occur.

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

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

Two short sentences with no filler, and the key behavioral clarification is front-loaded right after the purpose statement. It is concise and well structured, though it sacrifices helpful context in favor of brevity.

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

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

The tool has 9 parameters, no output schema, and no annotations, yet the description does not explain what the result looks like, how the extra parameters are used, or what 'ok' means operationally. Even with good schema coverage, an agent cannot tell whether this returns a boolean, throws on failure, or makes a network request.

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

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

Schema description coverage is 100%, so the baseline is 3 and the schema already explains each parameter. The tool description adds no parameter-level meaning and does not reconcile why parameters like city, json, and path are relevant to a URL-opening check, though the individual schema descriptions mitigate this.

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 ('URL'), and adds a clarifying constraint that no browser is launched. This is especially useful given the 'browser' in the tool name and helps distinguish it from browser-launching alternatives like playwright-url-ok, though it does not name siblings explicitly.

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 such as playwright-url-ok, web-fetch, or fetch-status. The phrase 'No browser is launched' implies a lightweight check, but the description never says when an agent should choose this over those options or when it should avoid it.

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

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

No annotations are present, so the description bears the full burden. 'Expression discarded' hints at non-retention, but it is ambiguous whether the input or the result is discarded, and there is no mention of side effects, return value, or failure modes.

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?

At two sentences it is short, but the second sentence ('Expression discarded.') creates ambiguity rather than adding useful context. The description is under-specified rather than efficiently concise.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, two vague sentences are grossly inadequate. Missing are what result is returned, how the parameters relate to evaluation, and why most parameters are marked 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?

Schema coverage is 100%, so the baseline is 3, but the description adds no relation between its 'a+b style arithmetic' claim and any of the nine parameters; none is labeled as an expression. The schema documents each field individually, but the agent cannot map the tool's stated purpose to a parameter such as 'query' or 'json'.

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'), but it is undercut by 'Expression discarded' and does not match the input schema, which contains no arithmetic-expression parameter at all. An agent cannot tell whether this evaluates math, validates shapes, or returns nothing.

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 siblings such as validate-json, search-query-len, or normalize-url. No context, prerequisites, or exclusions are given.

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

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

No annotations are provided, so the description carries the behavioral burden. It does disclose one meaningful trait: 'Page content is not stored,' which is a useful non-retention guarantee. It does not mention network behavior, error handling, rate limits, or side effects, but the storage disclaimer plus the stated output scope justify a middle score.

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 front-loaded and economical: it states the output behavior first and the storage guarantee second, with no wasted words. Both sentences earn their place. It is minimal, though the minimalism contributes to the incompleteness captured in other dimensions.

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

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

Given 9 parameters, no output schema, no annotations, and many sibling tools, this description is too thin for correct invocation. It does not state which parameters are required, how the parameters relate to the URL result, what the return shape is, or when to avoid this tool. The agent would need to inspect schemas and infer heavily.

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 itself adds little parameter-level meaning and does not clarify that `url` is the operative parameter while many others appear designed as discarded checks. However, each schema property has its own description, so the schema carries most of the parameter semantics.

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

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

The description clearly states the operation: 'Return host, scheme, and HTTP status for a URL.' This is a specific verb and resource, so an agent can see it is a URL-introspection tool. It does not explicitly differentiate it from overlapping siblings like fetch-status, normalize-url, or web-fetch, 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?

There is no guidance on when to use this tool versus alternatives, no exclusions, and no named sibling alternatives. The sentence implies it is for URL metadata, but with many overlapping sibling tools, the agent is left to infer applicability. 'Page content is not stored' is a behavioral note, not usage 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 must disclose behavior itself. It contributes one useful behavioral fact—'No identifiers are retained'—but says nothing about side effects, whether inputs are sent externally, what the output contains, or whether the operation is read-only. For a tool accepting 9 heterogeneous inputs, this is a thin 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 no wasted words and the main idea front-loaded. It is concise, even though the brevity comes at the cost of missing essential context covered under other dimensions.

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 annotations, and no output schema, the description must explain what classification outputs look like and how to invoke it. It provides only a general purpose and a privacy guarantee, leaving an agent unable to predict the result or construct a valid call confidently.

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

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

Schema coverage is 100%, so every parameter already has a description in the schema; the tool description adds no parameter-level meaning. Per the high-coverage baseline, this is an adequate 3.

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

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

The description names an action ('Show') and an object ('this request is classified'), but 'classified' is undefined: no classification categories, output shape, or relationship to the tool name 'compatibility' is given. It does not distinguish the tool from the many siblings like validate-json or file-path-ok, so it is a vague but not tautological purpose.

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

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

There is no guidance about when to use this tool instead of the sibling checkers, no stated conditions or exclusions, and no example of an appropriate request. The only additional sentence is a privacy note, which does not help select the tool.

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

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

With no annotations provided, the description must carry the behavioral disclosure burden. It does state the central transformation and a meaningful non-goal (no WHOIS/ownership data), which is useful. But it does not disclose the output format, error behavior, or how the nine optional parameters other than host are handled, leaving partial transparency.

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

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

The description is a single front-loaded sentence with no filler; every word contributes to purpose or scope. The non-goal clause 'without WHOIS or ownership data' earns its place by preventing a common misuse.

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

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

Given nine optional parameters, no output schema, and no annotations, one sentence is not enough for reliable invocation. The description leaves unclear which field to populate, what the split result looks like, and what happens if multiple unrelated parameters are supplied. This is a significant gap for an agent deciding how to call the tool correctly.

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

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

Schema description coverage is 100%, so the structured schema already documents every parameter; the description adds almost no parameter-level meaning. It implicitly points toward hostname-related input but never names the `host` property or clarifies the role of the many unrelated optional fields.

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

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

The description names a specific verb ('Split') and resource ('hostname') and states the result ('labels'), so the core operation is clear. The 'without WHOIS or ownership data' clause adds an explicit non-goal, though it does not directly differentiate among sibling shape tools like github-repo-shape or jira-key-shape.

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

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

It provides a clear use context: use when a hostname needs to be split into labels. It also gives an explicit boundary by saying WHOIS and ownership data are not included, so an agent can avoid using it for ownership lookups. However, it does not name sibling alternatives or explain when a different domain/shape tool should be preferred.

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

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

The description mentions it performs a HEAD request and returns status, which is transparent about the core behavior. However, it does not explain side effects (e.g., network call), error handling, or the purpose of the many other parameters (e.g., city, feed, json) that appear in the schema. The extra parameters are not addressed, leaving behavior ambiguous.

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 brief and to the point, which is good. However, it omits essential context about parameters and usage, making it too terse to be fully effective. It achieves conciseness but sacrifices necessary 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?

Given the lack of a required parameter and the presence of nine optional parameters, the description does not provide enough context to know how the tool behaves with different inputs. It does not explain what happens when multiple parameters are provided or how to choose among them. The absence of an output schema is acceptable, but the description alone is insufficient for correct use.

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

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

The schema descriptions are inconsistent with the tool's stated purpose. For example, the 'url' parameter is described as 'HTTPS URL to normalize or cite' rather than for a HEAD request. Other parameters like 'city' and 'zone' seem unrelated and their descriptions do not align with the action of checking a URL status. This misalignment makes it difficult to know which parameter to use.

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

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

The description clearly states the action (HEAD a public URL) and the result (return status only), which is specific and distinguishes it from content-fetching tools. However, it does not explicitly identify which parameter corresponds to the URL, and it does not differentiate from sibling tools that also check URLs (e.g., browser-url-ok).

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

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

The description provides no guidance on when to use this tool versus alternatives like normalize-url or web-fetch. It does not mention any conditions, limitations, or scenarios where this tool is preferred.

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

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

With no annotations, the description carries the full burden; it discloses only that the path is discarded. It does not state whether the tool validates against a Figma URL pattern, returns matched components, errors on non-Figma URLs, or performs any network access. This is insufficient for an agent to predict behavior.

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

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

The description is extremely short and front-loaded with the core action. The second sentence, 'Path discarded,' is compact but somewhat ambiguous, so it does not quite reach the zero-waste clarity of the top examples.

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

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

Given no output schema and no annotations, an agent doesn't know what the tool returns or how success/failure is signaled. The description also omits any expected URL format beyond 'Figma file URL' and doesn't account for the unusual 9-parameter schema. It is not complete enough for safe 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?

The schema already covers all parameters with descriptions (100% coverage), so the baseline is 3. The description adds one relevant clarification—'Path discarded'—which tells agents to ignore the schema's path parameter. It does not clarify the relationship of the other eight parameters to this tool, but the schema descriptions already provide the literal meaning.

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 ('Parse') and a specific resource ('a Figma file URL'), and the tool name reinforces the shape-check purpose. It is not a tautology. However, it doesn't explicitly say what 'parse' produces or contrast itself with sibling tools like normalize-url or github-repo-shape.

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

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

There is no statement of when to use this tool versus the many sibling URL/shape tools such as normalize-url, browser-url-ok, or domain-shape. The only hint, 'Path discarded,' addresses an input edge case rather than selection criteria, so an agent gets no 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?

The description usefully discloses 'No disk access,' which is a meaningful safety property and clarifies that this is a purely static check. However, with no annotations and no output schema, it does not state whether the tool returns a boolean, throws on invalid input, or what 'safe' means in terms of validation rules.

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, front-loaded sentences. The first states the purpose and the second adds a key behavioral constraint. There is no unnecessary repetition or 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 compactness, the description is not enough for an agent to confidently call the tool. It lacks return semantics, error behavior, a definition of 'safe,' and any explanation of why the schema accepts eight additional unrelated fields. The schema documents parameter names well, but the overall tool contract remains ambiguous.

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

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

The input schema has 100% description coverage, so each parameter is individually documented. The tool description itself adds little parameter-level meaning and does not explain why non-path parameters like url, city, json, zone, and query exist or how they relate to a path safety check.

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

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

The description states a clear action and resource: 'Check whether a path looks safe.' However, 'safe' is left undefined—it could mean syntactically valid, path-traversal-free, normalized, or OS-specific. The input schema also includes many unrelated optional parameters, which further muddies what the tool actually does.

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

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

There is no guidance on when to use this tool versus alternatives. Sibling tools like browser-url-ok, normalize-url, domain-shape, and wiki-title-ok cover similar shape/safety checks, but the description does not mention when file-path-ok is the right choice. 'No disk access' is a behavioral property, not a usage guideline.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only names the external backend and reveals nothing about network dependence, failure modes, output shape, or the fact that many inputs are described as discarded.

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

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

The description is a single compact sentence with no filler and the core result front-loaded. It is terse but not wasteful; however, it is so brief that it sacrifices actionable 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?

Given nine optional parameters, no annotations, and no output schema, the description is incomplete. It fails to explain which parameter to provide for a place, what the return value looks like, or how the other schema fields relate to the geocoding outcome.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds no parameter-level meaning and does not identify which input supplies the place, though the schema itself documents each parameter at least partially.

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 output ('Latitude and longitude for a place') and the source ('via Open-Meteo'), so an agent can infer this is a geocoding/lookup tool. It lacks an explicit verb and does not distinguish itself from sibling tools like weather-hint, which also concerns places.

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

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

No guidance is given on when to use geo-hint versus weather-hint or other sibling tools. It does not mention what kind of request should route here, nor does it name any alternative or exclusion condition.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only says 'Parse' and does not mention that other fields are discarded, how invalid URLs are handled, or what the parse output looks like. It gives a basic read-only impression but little else.

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. It directly states the core operation and object, which is appropriately concise for the tool's apparent 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?

For a tool with nine optional parameters, no output schema, and no annotations, the description is too thin. It does not tell the agent which parameter to supply, what the return value contains, or how to disambiguate this from sibling URL-shape tools. The schema's discard hints help, but the overall usage context remains incomplete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds useful meaning by tying the 'url' parameter to GitHub owner/repo extraction, which the schema's generic 'normalize or cite' line does not convey. However, it provides no guidance on why eight other properties exist or whether they are relevant.

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

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

The description uses a specific verb ('Parse') and resource ('owner and repo' from 'a GitHub URL'). It clearly distinguishes this from sibling shape tools like figma-url-shape and jira-key-shape by naming the GitHub-specific purpose.

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

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

The description implies the tool should be used when you have a GitHub URL and need to extract owner and repo. However, it provides no explicit guidance about when not to use it or which sibling tool to prefer for other URL shapes.

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

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

With no annotations, the description must carry behavioral disclosure. It does state that only the count is returned and titles are discarded, which is useful, but it does not mention return format, network behavior, failure modes, or whether parameters are used. This is partially transparent but not complete.

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 action and resource are front-loaded, and the discarded-title restriction follows naturally. 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 simple counter, the core call is understandable, but with nine optional parameters, no output schema, and no annotations, the description should clarify whether any parameters are needed and what the exact return value looks like. These gaps keep it at minimum viable.

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. The description adds no parameter-level meaning beyond what the schema already provides; 'Titles discarded' overlaps with the feed parameter description rather than clarifying the nine optional parameters.

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

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

The description names the exact operation ('Count') and the target resource ('current Hacker News front-page stories'), and adds an explicit output restriction with 'Titles discarded.' This is specific enough for an agent to distinguish it from the generic fetch/validation siblings.

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

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

The description gives no guidance on when to use this tool instead of web-fetch, fetch-status, or other sibling tools, and it states no exclusions or prerequisites. Usage is only implied by the narrow resource scope, not explicitly routed.

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 is a noun phrase that does not state whether the tool returns a list, validates names, accepts input, or performs any observable action. The schema's repeated 'discarded' language suggests side-effect-free behavior, but the description itself provides no behavioral transparency.

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

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

The description is a single short sentence with no filler, and the core resource is front-loaded. It is concise to the point of underspecification, but structurally it is efficient and easy to parse.

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

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

Given 9 optional parameters, no annotations, no output schema, and several closely related sibling tools, a one-line noun phrase is far too thin. The agent cannot determine what the tool returns, how parameters affect behavior, or when to prefer it over timezone or utc-time. This is a substantial gap.

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

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

Schema description coverage is 100%, so each of the 9 parameters has an explicit description, meeting the baseline. However, the tool description adds no meaning to the parameters, and many params (ref, url, city, feed, host, json, path) appear unrelated to IANA timezone names. The description does not explain how these parameters relate to the tool's purpose.

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

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

The description names a specific resource (IANA timezone names) and a purpose ('for clock calls'), making it reasonably clear that this tool provides timezone name data. However, it lacks a verb such as 'returns' or 'lists', and does not explicitly distinguish itself from sibling tools like timezone or utc-time beyond the clock-call context.

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

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

There is no guidance about when to use this tool versus alternatives. The phrase 'for clock calls' hints at one use case, but no exclusions or comparisons to siblings like timezone or utc-time are provided. An agent would have to guess when iana-zones is the appropriate 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 bears the full burden of behavioral disclosure. It conveys that this is a read-only fetch and that output is limited to group counts, but it omits error behavior (e.g., missing robots.txt), rate limits, and any other side effects or caveats.

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

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

The description is a single efficient sentence with no filler. The verb, resource, and output limitation are front-loaded, and every word contributes meaning.

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 not enough to call it correctly. It should identify which parameter supplies the target site (host or url) and note that the remaining parameters are irrelevant or discarded; without that, the agent has to guess.

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

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

Schema coverage is 100%, so the baseline is 3, but the parameter descriptions actively conflict with the tool's stated purpose: 'url' is described as 'normalize or cite', 'ref' and 'json' are 'discarded after the shape check', and 'query' is 'discarded after the length check'. None of them tells the agent how to specify the robots.txt source, so the high schema coverage does not rescue invocation clarity.

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

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

The description names a specific action and resource ('Fetch a public robots.txt') and an explicit output shape ('return group counts only'), which also separates it from generic siblings like web-fetch or fetch-status. It loses a point because nothing in the description links this purpose to any of the nine input parameters, so the tool's intended target is ambiguous.

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?

'Return group counts only' implies the tool is for count-only needs rather than full robots.txt content, giving some usage context. However, it never says when to prefer this over siblings such as web-fetch or fetch-status, nor does it state 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 provided, the description carries the full burden of behavioral disclosure. It only says 'Key discarded', which notes non-retention of an unspecified key, but it does not state what a valid shape looks like, what the tool returns, what it does when inputs are invalid, or why the schema contains unrelated fields.

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 action, with no filler or repetition. The terse style contributes to under-specification, but conciseness itself is handled well.

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

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

Given seven unrelated-looking parameters, no output schema, and no annotations, the description is far too thin for reliable invocation. It never says which parameter carries the Jira key, what result is returned, or how this tool compares to the other shape-checking siblings.

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

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

The input schema describes each of the seven parameters individually, so the high schema_description_coverage establishes a baseline of 3. The description adds no per-parameter meaning and even introduces a 'key' concept that does not map cleanly to any schema property, but the schema itself still documents the fields.

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

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

The description clearly identifies the action ('Check') and the domain ('Jira issue key shape'), which distinguishes it from shape-checking siblings like domain-shape or github-repo-shape. However, it does not clarify which of the seven heterogeneous schema fields holds the Jira key, so the operational purpose is less crisp than it could be.

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

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

There is no guidance on when to use jira-key-shape versus alternatives such as validate-json, domain-shape, or github-repo-shape. The only hint is the tool name and the terse first sentence, leaving selection entirely to inference.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose that the body is discarded, which is a useful behavioral trait, but it does not explain whether this performs a live network request, how errors are signaled, or what statuses may be returned.

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

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

The description is only two sentences and both contribute meaning: the first states the core behavior and the second clarifies an important limitation. There is no redundant or filler 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 nine optional parameters and no output schema or annotations, so the description needs to tie the schema together. It covers only the URL/status aspect and leaves the roles of city, feed, json, timezone, and query unexplained in relation to the stated purpose, making the definition incomplete for an agent.

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 does not clarify how the many unrelated-looking parameters (city, feed, json, zone, query) relate to the stated 'public library docs URL' purpose, but the schema itself provides per-parameter 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 states a specific verb and resource: it returns an HTTP status for a public library docs URL and explicitly notes the body is discarded. This is clear, but it does not distinguish the tool from siblings like fetch-status or browser-url-ok, so it stops short of a 5.

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

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

The phrase 'public library docs URL' implies the intended use case, but the description gives no explicit when-to-use vs. when-not-to-use guidance and does not mention any alternative sibling tools. With nine optional parameters of very different kinds, the usage scope remains ambiguous.

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 readOnlyHint annotation already covers read-safety, and the description adds that values are discarded. However, the description claims to count keys while the output schema constrains the result to constant 0, an unresolved contradiction about the actual output behavior. Additionally, it fails to explain how the multiple string parameters relate to a JSON object input.

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

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

The description is two short sentences with no wasted words. The core action is front-loaded and the clarifying detail about values is concise and relevant.

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

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

For a tool with seven input parameters and a contradictory output schema, this description is insufficient. It leaves unresolved how the flat input fields correspond to the stated JSON-object input, and it does not reconcile the constant-zero output with the claimed counting behavior.

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

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

Schema description coverage is 100%, so all parameters are already documented. The description does not add parameter-level meaning beyond that, and it introduces ambiguity by referring to a 'JSON object' while the schema defines flat string fields. The baseline of 3 applies since the schema carries the 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 a concrete operation: count keys in a JSON object. The clause 'Values discarded' clarifies the focus on keys rather than values, giving it a distinct purpose among JSON-related tools. It does not explicitly name alternatives, but the function is specific enough to be understood.

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

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

There is no guidance on when to use this tool versus siblings like validate-json or other shape-checking tools. The description provides no exclusion conditions or alternative references, leaving the selection context entirely to inference.

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

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

With no annotations, the description must carry the behavioral burden. It usefully discloses that query and fragment are dropped and that the output consists of origin, host, and path. But it does not mention that the other accepted parameters appear to be discarded/no-ops, nor what happens with invalid URLs.

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

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

The description is two short sentences with the core behavior front-loaded and no filler. It is concise and scannable.

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

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

The tool has nine optional parameters, no output schema, and no annotations, yet the description covers only the URL case. An agent cannot tell whether the other parameters are relevant, ignored, or side effects, so the description is not complete enough for this schema's complexity.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no new meaning to the url parameter beyond the schema's 'HTTPS URL to normalize or cite' and says nothing about the other eight parameters, relying entirely on their 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 states a specific operation and resource: it returns the origin, host, and path for a URL, which distinguishes it from sibling tools like web-fetch or browser-url-ok. However, it does not explicitly contrast with those siblings, and the 9-parameter input schema makes the actual scope confusing.

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 choose normalize-url over alternatives, and there are no exclusions or conditions. The schema hints at unrelated uses (weather, timezone, JSON validation) without any explanation of when those parameters should be used, so an agent gets no routing help.

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 transparency burden. It does disclose one meaningful behavioral trait: no browser is launched, which signals this is not a rendering or full Playwright automation tool. However, it does not explain whether a network request is made, what results are returned, or whether any state changes occur, leaving significant behavioral gaps.

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

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

Two short sentences, no filler, and the core purpose plus a key differentiator are front-loaded. Every word earns its place. This is an exemplary concise description.

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 explains only the basic check and the no-browser behavior. It does not clarify what 'opened' means, what the output format is, or how the many parameters relate to the check. For a tool with this complexity and no other structured metadata, the description is under-specified.

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 reported at 100%, so the schema already documents every parameter. The description adds no parameter-specific meaning beyond what the schema provides. Baseline 3 is appropriate because the schema carries the load and the description does not need to duplicate it.

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

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

Description clearly states the tool checks whether a URL can be opened, with a specific verb and resource. It also adds a distinguishing behavioral detail, 'No browser is launched,' which helps separate it from browser-url-ok. However, 'opened' is somewhat ambiguous—it could mean HTTP accessibility, rendering, or URL format—so it is not a perfect 5.

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

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

The description gives no explicit guidance on when to use this tool versus siblings like browser-url-ok, fetch-status, normalize-url, or web-fetch. The statement 'No browser is launched' implicitly suggests a lightweight check, but no condition, alternative, or exclusion is provided. The agent is left to infer use cases.

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 burden. The only behavioral claim, 'Query discarded,' largely repeats the query parameter's schema description ('discarded after the length check'), and there is no statement about side effects, network access, or return 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?

Two short sentences with no filler: the operation is front-loaded and the retention behavior is stated. Every word earns its place, even though more context would be desirable elsewhere.

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

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

The tool has nine optional parameters, no annotations, and no output schema. The description does not identify which parameter is intended, does not explain why the other parameters exist or are ignored, and does not describe the return value. This 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 tool-level description adds no parameter-level meaning beyond naming the search query, which the query param description already provides. 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 names a specific operation — count characters in a search query — and the resource is clear. It does not explicitly differentiate this from sibling counting tools like memory-key-count or hn-front-count, but the verb and object are unambiguous.

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

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

The intended use is implied: call this when you need the length of a search query. However, there is no explicit when-to-use guidance, no discussion of alternatives, and no exclusion criteria for the nine optional parameters.

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 fails. It claims to be a catalog of HTTP status codes, yet the input schema lists seven unrelated parameters that are described as discarded, normalized, checked, or cited. This mismatch leaves the agent unable to predict what actually happens when the tool is called.

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

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

The description is only one sentence, but it is under-specified rather than genuinely concise. It front-loads no actionable information and does not earn its place because it mostly repeats the tool name.

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

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

Given seven parameters, no annotations, and no output schema, the description is severely incomplete. It does not explain how parameters relate to the catalog, what will be returned, or how the agent should format a valid call.

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

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

The input schema provides descriptions for all seven parameters, so schema coverage is high and the baseline is 3. The description itself adds no parameter information and does not help reconcile the HTTP-status-codes purpose with the unrelated parameters.

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

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

The description 'Short catalog of common HTTP status codes' essentially restates the tool name 'status-catalog' and tells the agent what the resource is rather than what the tool does. It lacks a specific verb and does not distinguish this tool from siblings like fetch-status or domain-shape.

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

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

No guidance is provided about when to use this tool versus alternatives such as fetch-status or normalize-url. The description implies it might be a reference for HTTP status codes, but it never states a concrete use case, prerequisites, or exclusions.

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

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

Annotations include readOnly=true and noAuthNeeded=true, and the description does not contradict them (no annotation contradiction). The phrase 'Prompt discarded' adds a small behavioral disclosure that inputs are not persisted, and schema parameters repeat 'discarded after the shape check', but the description itself discloses nothing about side effects, what a 'shape check' means, or any other 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?

At eight words the description is minimal, but this is under-specification rather than conciseness: it omits what the template contains and how parameters map to it. The 'Prompt discarded' sentence is a reasonably efficient behavioral note, but the front-loaded clause is too thin to be informative.

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 10 cross-domain parameters and no output schema, the description is severely inadequate. It never explains the output template's structure, the relationship between the parameters and the returned steps, or why inputs are only 'shape-checked', so an agent cannot predict what will be returned or what the tool is actually for.

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 effectively 100% — every parameter has an individual description (e.g., 'Git ref name; discarded after the shape check', 'JSON text to validate; discarded after the check') — so the baseline of 3 applies. The tool description names no parameters and adds no meaning beyond the schema, neither compensating nor degrading.

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 ('Return a three-step thinking template'), but this is essentially a restatement of the name 'think-steps'. It never defines what the three steps are, what problem they address, or how this differs from the 23 sibling tools, leaving the actual purpose vague.

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

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

There is no guidance on when to use this tool versus alternatives. The schema's 10 heterogeneous parameters (ref, url, city, feed, host, json, path) span Git refs, URLs, cities, JSON, and files, yet the description offers no decision rule about which input to provide or when a sibling like validate-json, normalize-url, or file-path-ok would be more 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?

No annotations are provided, so the description carries the full burden. It implies a read-only operation (fetching current time) but does not explicitly state side effects, permissions, or that it is non-destructive. The presence of many irrelevant parameters may also confuse the agent about actual behavior.

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

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

The description is a single, brief sentence that is easy to parse. It follows a straightforward structure without extraneous details.

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

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

Given the complexity of the schema (9 optional parameters) and the absence of an output schema, the description is incomplete. It does not clarify the purpose of the extra parameters, the expected input format, or the nature of the output. The agent would likely struggle to call this tool correctly without additional context.

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

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

The description only contextualizes the 'zone' parameter. The schema lists 9 parameters with individual descriptions, but the tool description does not explain why parameters like 'ref', 'url', or 'city' exist or how they relate to the core function. This leaves the agent uncertain about which parameters are actually relevant.

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

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

The description clearly states the tool returns the current time for a named IANA timezone. It is specific about the resource (timezone) and action (current time), but does not explicitly distinguish it from siblings like 'utc-time' or 'iana-zones'.

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 over alternatives. It does not mention conditions such as needing a specific timezone or when to prefer 'utc-time'.

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, this one-liner carries the entire behavioral burden, but it only states the value produced and omits format (Unix seconds vs ISO), determinism, side effects, or whether the optional parameters affect output. This is minimal disclosure rather than useful transparency.

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

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

The definition is a single front-loaded sentence with no redundant wording. Every word earns its place, though the content is sparse.

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 an unexpectedly broad nine-parameter input schema, the description is too short to be complete. It does not state the output format or clarify why the parameters are present or how they are treated, leaving an agent to guess.

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 describes all nine parameters with 100% coverage, so the baseline is met and the description does not need to repeat them. The description adds no parameter-level meaning and leaves the odd relationship between utc-time and parameters like url/json unexplained.

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

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

The phrase 'Current UTC timestamp' clearly communicates that the tool returns the current UTC time, so an agent knows the core purpose. However, it is a noun phrase rather than an explicit 'returns/gets' action and does not distinguish this from sibling tools like timezone or iana-zones.

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 contains no guidance about when to use utc-time versus alternatives such as timezone or iana-zones. The only usage signal is the implicit 'use when you need the current UTC timestamp.'

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 second sentence ('The body is discarded.') is a useful behavioral disclosure about non-persistence, and 'check' implies no mutation. With no annotations, however, the description omits what the tool returns for valid versus invalid JSON and any error behavior, so transparency is partial.

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

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

Two short sentences with no filler; the purpose is stated first, and the second sentence adds a behavioral fact. This is appropriately sized for the tool's simple function.

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

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

The tool is simple and the schema documents all parameters, but there is no output schema and the description does not state the return format or acceptance criteria for 'valid'. The discarded-body note helps, yet an agent is left to infer the result representation.

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

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

All seven parameters already have schema descriptions, so the schema covers parameter meaning and the description adds little. It does not clarify how the generic 'body' relates to the 'json' parameter or the other six fields, keeping this 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 gives a specific verb ('Check') and resource ('body') and names the validation criterion ('valid JSON'), so the core action is clear. It does not explicitly tie 'body' to the schema's 'json' parameter or name sibling distinctions, though the JSON focus already separates it from most sibling 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?

The use case is implied: invoke this when a JSON body needs validity checking. It does not name alternatives or state when not to use it, but the tool's purpose self-signals the trigger condition.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the data source (Open-Meteo) but does not mention whether the call is read-only, network-dependent, rate-limited, or what happens on failure. For a tool with no annotations, this is insufficient transparency.

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

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

The description is a single, front-loaded sentence with no filler. It communicates the core purpose and the data provider efficiently. 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 the tool has nine parameters, no annotations, and no output schema, a one-sentence description is not enough context for an agent to invoke it correctly. The description does not explain which parameter is meaningful, whether any parameter is required, or how the temperature result is returned. This leaves important operational gaps.

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

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

The input schema has 100% description coverage, so the baseline is 3; the description does not need to repeat parameter details. However, the description mentions only 'city' while the schema exposes eight other seemingly unrelated optional parameters, and it does not clarify which parameters are actually used or required. This creates ambiguity that the schema's individual descriptions do not resolve.

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

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

The description clearly states the tool's function: providing the current temperature for a city using Open-Meteo. The provider name adds specificity, and the weather domain distinguishes it from sibling hint tools such as geo-hint or timezone. It lacks an explicit verb like 'get' or 'fetch', but the intent is unmistakable.

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

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

There is no guidance about when to use this tool instead of alternatives, no mention of required inputs, and no exclusions or prerequisites. The description simply names the action without contextualizing it relative to the sibling tools. An agent is left to infer that the 'city' parameter is the relevant one.

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

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

With no annotations provided, the description carries the behavioral burden and usefully discloses that the response body is discarded, preventing agents from assuming page content is available. It does not cover redirects, timeouts, or auth, but the key non-obvious behavior is surfaced.

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

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

The description is two short sentences with no filler. It front-loads the core action and includes the crucial 'Body discarded' caveat efficiently.

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

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

Given a 9-parameter schema, no annotations, no output schema, and close sibling tools, the description is too sparse. It does not explain which parameter to populate, what the output structure looks like beyond status/content-type, or how it differs from fetch-status and browser-url-ok.

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 parameters are already documented and the baseline is 3. The description adds no parameter-specific guidance and leaves ambiguity about which of the many schema fields web-fetch actually consumes, such as url versus host or feed.

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 what the tool does: returns HTTP status and content type for a public URL, with the body discarded. It is specific about the resource and result, but it does not explicitly distinguish web-fetch from sibling tools like fetch-status or browser-url-ok.

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

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

The description implies a lightweight, header-only check via 'public URL' and 'Body discarded', but it does not explicitly state when to use this tool versus alternatives or provide exclusions. Usage context is inferable but not stated.

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 detail—title is discarded after the call—which goes beyond the annotations. However, the referenced 'title' does not appear as any schema property, making the statement confusing rather than fully transparent.

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

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

The description is extremely short and front-loaded, with two sentences that each carry some information. However, the brevity omits the essential parameter-product mapping, sacrificing practical utility for conciseness.

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

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

For a tool whose purpose is to check a Wikipedia title, the lack of any parameter identifying the title makes the definition incomplete. There is no output schema, and the existing schema descriptions are generic and unrelated to the stated purpose.

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

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

The schema contains seven properties with descriptions, but none of them is a title. The description does not explain how any parameter maps to the Wikipedia title check, so it adds no meaningful parameter semantics. An agent cannot determine which input to pass.

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

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

The description uses a specific verb ('Check') and resource ('whether a Wikipedia title exists'), making the core purpose clear. It is not a tautology and the intent is understandable, even though it does not explicitly differentiate from sibling 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 on when to use this tool versus alternatives like normalize-url or fetch-status. No preconditions, exclusions, or situational context is provided, so an agent must infer the appropriate usage entirely.

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