Europe/Stockholm clock

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 discloses that task text is discarded and what is returned, but it never explains the relationship between the stated purpose (find a gateway) and the 9 unrelated input parameters (city, zone, json, feed, etc.). An agent cannot tell what happens to these inputs or why a gateway-finder takes a timezone or JSON text.

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

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

Two sentences with zero waste and the purpose front-loaded. The 'Task text discarded' note is placed last and earns its place as a behavioral disclosure. Length is appropriate for the information conveyed.

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

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

This is a complex tool: 9 unrelated parameters, no output schema, no annotations, and 27 siblings. The description explains the return payload but not the parameters or the selection logic. An agent would struggle to understand why a gateway-finder accepts a city name, timezone, or JSON text, making the description incomplete for this complexity level.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description itself adds no parameter detail. The schema carries all of it, but the schema entries are cryptic for a gateway-finder ('discarded after the shape check' on nearly every field), so the semantics remain unclear despite complete coverage.

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

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

States a specific verb (find) and resource (public pay-per-call tool gateway Monid) and lists the return payload (CLI setup, how-it-works, skill file, remote MCP hops). Some confusion from the name-description mismatch: 'agent-tool-index' implies an index of tools, but the description is about a gateway, which obscures its relationship to the 27 sibling check/hint tools.

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

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

No guidance on when to use this tool versus the 27 siblings. No alternatives are named and no conditions are stated. The only usage hint is implicit in the name 'agent-tool-index', which the description never articulates. 'Task text discarded' 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 behaviors. It only notes that no browser is launched, but does not clarify whether a network request is made, if the operation is read-only, or what side effects (if any) occur. Schema hints like 'discarded' and 'no disk access' appear in parameter descriptions, but the main description omits these, leaving the tool's behavioral profile vague.

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

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

The description is a single sentence with no filler. It immediately states the core action and the key limitation (no browser launch), making it highly 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 the tool has 9 parameters, no annotations, and no output schema, the description is far too sparse. It does not explain the return value, which parameter is mandatory (though all are optional), or how to interpret 'can be opened.' The mismatch between the simple description and the complex schema makes the tool insufficiently specified 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?

Although schema coverage is 100%, the description does not explain which parameter is the actual URL to check, nor how the many unrelated parameters (ref, city, feed, host, etc.) relate to the tool's purpose. The schema descriptions are cryptic and the main description fails to clarify the role of each parameter, so an agent cannot confidently map inputs to the intended 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: 'Check whether a URL can be opened' and adds a distinguishing trait 'No browser is launched.' However, it does not explicitly contrast with sibling tools like playwright-url-ok, leaving some ambiguity about what 'can be opened' means (e.g., syntactic validity vs. live fetch).

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

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

No guidance on when to use this tool versus alternatives such as normalize-url or fetch-status. The description does not mention conditions, exclusions, or preferred scenarios, leaving the agent to infer usage from the name alone.

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

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

With no annotations, the description must carry behavioral disclosure. It only says 'Expression discarded,' but there is no expression parameter, and it doesn't explain side effects, permissions, or what happens to the inputs. It is misleading and 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 extremely short (two sentences) but that is under-specification, not conciseness. It front-loads nothing useful and omits critical context about parameters and behavior.

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 parameters, no output schema, and no annotations, the description is drastically incomplete. An agent cannot infer the tool's purpose, correct usage, or expected results. It fails to provide even a basic level of 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 schema descriptions cover 100% of parameters, but the tool description adds no unifying meaning—it doesn't explain how these nine disparate parameters relate to arithmetic or to each other. The baseline 3 is not met because the description actively contradicts the schema's apparent purpose, leaving agents unable to map inputs to the tool's function.

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 claims to 'Evaluate a+b style arithmetic' but the schema has no arithmetic expression parameter; it lists unrelated fields like ref, url, city, and query. This creates a mismatch that confuses rather than clarifies the tool's actual purpose, and it does not differentiate from siblings like normalize-url or fetch-status.

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

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

There is no guidance on when to use this tool versus any of the 26 sibling tools. No context, no exclusions, no mention of alternatives. The description offers zero help for selection.

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

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

With no annotations, the description must carry the full burden. It discloses only that 'page content is not stored,' but it omits other behavioral traits: the tool discards most inputs (as per parameter descriptions), makes no disk access, and likely performs network operations. This is insufficient for a tool with nine diverse parameters.

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 at two sentences and front-loads the primary action. However, its brevity sacrifices necessary detail, making it structurally efficient but substantively incomplete.

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

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

For a tool with 9 parameters and no output schema, the description is severely incomplete. It explains only the URL case and ignores the other eight parameters, the tool's name ('citation'), and how the tool relates to its siblings. An agent cannot infer correct usage 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?

Schema coverage is 100% (every parameter has a description), so the baseline is 3. The description only implicitly refers to the URL parameter and adds no additional meaning for the other eight parameters, relying entirely on the schema's terse notes like 'discarded after the shape 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 specific action for a URL: returning host, scheme, and HTTP status. However, it does not differentiate from sibling tools like fetch-status or normalize-url, and it ignores the tool's broader parameter set (city, feed, json, etc.), making the true purpose 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?

No guidance on when to use this tool versus alternatives. The description does not mention any exclusions, prerequisites, or conditions that would help an agent select it over similar tools like fetch-status or web-fetch.

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

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

With no annotations, the description carries the full burden, but it only adds 'No identifiers are retained.' This is a useful privacy note, yet it does not disclose whether the tool makes external calls, accesses local data, returns a classification format, or has other side effects. The schema's per-parameter notes like 'no disk access' and 'discarded after' help, but the overall tool behavior remains 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?

The description is only two sentences, front-loaded with the core purpose and followed by a privacy note. There is no redundant wording or filler, so it earns a high score for conciseness despite being semantically thin.

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

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

This is a nine-parameter tool with no output schema and no annotations, yet the description does not explain what classification result the agent should expect or which parameters are appropriate in which scenarios. The rich schema covers parameter meaning, but the tool's core semantics and return value are missing, making it insufficient for reliable invocation.

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

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

Schema description coverage is 100%, and each of the nine parameters has an individual explanation, including discard behavior and constraints. The description itself adds no parameter-level meaning, 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 states a verb and object ('Show how this request is classified'), so it is not a pure tautology, but it leaves the classification scheme undefined. An agent cannot tell what dimensions or categories are being classified, nor how this differs from sibling shape/classification tools such as domain-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?

The description gives no guidance on when to use this tool versus any of the many sibling tools. There are no alternatives named, no conditions, and no exclusions, so the agent must guess when 'compatibility' 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 must fully disclose behavior. It only mentions that the tool avoids WHOIS/ownership data, which is a partial disclosure. It does not explain what happens with the other 8 parameters (are they ignored? validated? cause errors?), nor does it describe return values or side effects. This is insufficient for an agent to safely invoke the tool.

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

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

The description is a single sentence, which is concise, but it omits critical information about the tool's actual scope. It is under-specified rather than efficiently concise, since it fails to address the multi-parameter schema and the behavior for non-host inputs. It does not front-load the fact that other parameters exist.

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 is completely inadequate. An agent cannot determine which parameters are actually used, what the tool returns, or how it behaves with inputs like 'city' or 'json'. The description covers only a fraction of the tool's surface area and leaves most usage ambiguous.

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

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

Schema description coverage is 100% – each of the 9 parameters has a description in the input schema, so the schema already documents them. The tool description adds no extra meaning beyond mentioning 'hostname', which maps to the 'host' parameter. Per the baseline, 3 is appropriate because the schema carries the semantic load, and the description does not enrich 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?

The description states a specific verb and resource ('Split a hostname into labels') and notes it lacks WHOIS/ownership data, which is clear for that narrow function. However, the input schema accepts 9 unrelated parameters (ref, url, city, feed, json, path, zone, query), so the description is misleading about what the tool actually operates on. It does not distinguish from sibling tools like github-repo-shape or jira-key-shape, which likely perform similar 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?

There is no guidance on when to use this tool versus alternatives. It does not mention any sibling tools, conditions, or exclusions. The description gives no context about which inputs are relevant or how to choose between this and other 'shape' tools.

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

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

With no annotations, the description carries the behavioral disclosure burden. It does disclose the HTTP method (HEAD) and that only status is returned, which is meaningful. It does not mention redirect handling, error behavior, or the fact that several schema parameters appear to be accepted yet 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?

A single, front-loaded sentence with no filler. It communicates the verb, resource, and output in under ten words.

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

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

The tool is complex (seven heterogeneous parameters, no annotations, no output schema), yet the description only addresses a single URL-checking behavior. An agent cannot determine which parameter to pass or what the returned status looks like.

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

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

The input schema descriptions cover all seven parameters, so the description need not repeat parameter details. The tool description adds no parameter-level meaning, and the mismatch between 'HEAD a public URL' and params like city/json/path remains unresolved.

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: 'HEAD a public URL' and 'return status only', which clearly identifies a lightweight status check. However, it doesn't distinguish fetch-status from sibling tools like browser-url-ok or status-catalog, and the large heterogeneous input schema makes the actual scope less certain.

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

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

No guidance is provided on when to use this tool rather than web-fetch, browser-url-ok, playwright-url-ok, or status-catalog. The phrase 'status only' implies a lightweight use case, but no alternatives or exclusion conditions are named.

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 full responsibility. It discloses one behavior ('Path discarded') but omits critical details: whether the operation is read-only, what the output format is, how other parameters are handled, and any side effects. This is insufficient for a tool with such a sparse 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?

While the description is short, it is under-specified rather than concise. For a tool with 9 parameters and no annotations, a single sentence is inadequate. The structure fails to convey essential information that an agent needs to call the tool correctly.

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 (9 parameters, no annotations, no output schema), the description is woefully incomplete. It does not explain what the tool returns, how to interpret results, or how the various parameters relate to the 'shape check'. An agent cannot reliably determine correct usage from this description alone.

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

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

Schema description coverage is 100%, so the schema already documents all 9 parameters. The description adds no extra meaning about them—it only mentions the URL implicitly via 'Figma file URL'. Since the schema does the heavy lifting, a baseline of 3 is appropriate; the description provides no additional value.

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

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

The description states a specific verb ('Parse') and resource ('Figma file URL'), and the mention of 'Path discarded' hints at validation behavior. However, it does not clarify what 'parse' means (e.g., validate, extract, normalize) or differentiate from sibling tools like normalize-url or browser-url-ok. It is clear enough to guess the purpose but lacks precision.

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

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

No guidance is given on when to use this tool instead of alternatives. It does not mention any conditions, prerequisites, or comparisons to sibling tools like github-repo-shape or jira-key-shape. The agent is left to infer its use case from the name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses that no disk access occurs, which is useful, but fails to mention what constitutes 'safe,' the return format, or any side effects. The single constraint is insufficient for a tool that likely performs a validation check.

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

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

The description is extremely concise—two short sentences with no fluff. It front-loads the core purpose and then adds a critical constraint. While it could be more informative, the structure is efficient and easy to parse, earning a high conciseness 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?

The tool has 9 parameters, but the description only addresses 'path' and gives no indication of what the other parameters do or whether they are ignored. There is no output schema, so the return behavior is unknown. The description is incomplete for a multi-parameter tool, leaving significant gaps in what an agent needs to call it correctly.

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

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

Schema description coverage is 100%, so every parameter has a description. The tool description itself adds no parameter-specific meaning beyond the schema, and the baseline of 3 applies because the schema already documents the parameters adequately. The description does not clarify how the extra parameters (url, city, etc.) relate to the 'path' focus.

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

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

The description states a specific verb and resource: 'check whether a path looks safe,' and adds a key constraint ('No disk access'). This clearly distinguishes it from disk-accessing path tools, though it doesn't explicitly name sibling alternatives. The purpose is unambiguous and specific to file paths.

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

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

No guidance is provided on when to use this tool versus alternatives like browser-url-ok or domain-shape. The 'No disk access' hint implies a safe context, but there is no explicit when-to-use or when-not-to-use instruction, leaving the agent to infer applicability.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states the output and provider. It does not mention which parameter is used, what happens to the other parameters, or any side effects. The schema mentions 'discarded' for several parameters, but that is in the schema, not the description.

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

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

The description is a single sentence, which is concise, but it is severely under-specified. It does not provide enough information to be useful, so it is not 'appropriately sized'—concision without substance is a deficiency.

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 parameters, no output schema, and no annotations, this description is drastically incomplete. An agent cannot determine which parameter identifies the place, what the response format is, or any constraints. It fails to compensate for the tool'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?

The input schema covers all 9 parameters with descriptions, achieving 100% schema description coverage. The tool description adds no additional meaning beyond what the schema already provides, so it sits at the baseline of 3.

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

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

The description states the output (latitude and longitude) and the data source (Open-Meteo), but it does not specify which of the 9 parameters identifies the place. The purpose is clear in a general sense but ambiguous regarding the input, making it difficult to distinguish from related tools like weather-hint.

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

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

There is no guidance on when to use this tool versus its many siblings (e.g., weather-hint, timezone, utc-time). The description does not mention alternatives, prerequisites, or conditions, leaving the agent without any routing information.

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

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

No annotations are provided, so the description must disclose behavior. It only mentions parsing owner and repo, but does not describe return format, error handling, or the fact that many schema parameters are ignored. The schema includes fields like 'city' and 'feed' which are unrelated to the stated purpose, and the description does not clarify this discrepancy.

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

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

The description is a single sentence with no waste, but it is under-specified for a tool with nine parameters and no output schema. It lacks structure that would help an agent understand the tool's full scope.

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

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

For a tool with nine parameters, no annotations, and no output schema, this description is severely incomplete. It does not explain what the tool returns, how the parameters relate, or how it handles invalid inputs, leaving an agent unable to call it correctly.

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

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

The description does not reference any of the nine parameters, so it adds no meaning beyond the schema. With 100% schema coverage, a baseline of 3 is warranted, but the description fails to clarify which parameter corresponds to the GitHub URL or what the other parameters are for, making it less helpful than the schema alone.

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 verb 'parse' and the resource 'owner and repo from a GitHub URL', making the primary purpose unambiguous. It also distinguishes itself from siblings like figma-url-shape and domain-shape by specifying GitHub repos.

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. It simply states the function without mentioning conditions, prerequisites, or comparisons to other shape tools.

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

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

With no annotations, the description carries the full burden. It discloses that titles are discarded and implies a count is returned, but it does not mention network access, rate limits, or how the 9 unrelated parameters affect behavior. This is minimal transparency.

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

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

Two sentences is concise, but it is under-specified, not appropriately concise. The description omits essential information about how to invoke the tool with the given parameters, making it inadequate rather than efficiently brief.

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, and no annotations, this description is severely incomplete. The agent has no idea which parameters are relevant, how they map to the tool's purpose, or what the expected return value is beyond a vague 'count'.

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

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

Schema description coverage is 100%, so baseline is 3, but the description adds no parameter information. More critically, the parameters (ref, url, city, feed, etc.) seem unrelated to counting HN stories, and their schema descriptions (e.g., 'discarded after the shape check') contradict the tool's stated purpose, making the parameters misleading.

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

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

The description states a clear verb ('Count') and resource ('current Hacker News front-page stories'), which is specific. However, it does not differentiate from any sibling (no other HN tool) and the mention of 'Titles discarded' adds minor confusion without clarifying the tool's scope.

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

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

No guidance on when to use this tool vs alternatives. There is no mention of context, prerequisites, or exclusions. The description simply states what it does, leaving the agent to infer usage.

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 carry the burden of behavioral disclosure, but it says nothing about side effects, return format, or whether the tool is a read-only lookup. The only behavioral hints, such as 'discarded after the shape check,' appear in the parameter schema rather than the description itself.

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 contains no filler, but it is a noun phrase rather than a complete statement and is under-specified for a tool with nine parameters. Brevity is present, but the structure does not efficiently convey the tool's operation.

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

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

With nine optional parameters, no annotations, and no output schema, a one-sentence description is severely incomplete. The description does not explain what the tool returns, how to request zones, or how the 'discarded after' parameters affect invocation, so an agent cannot reliably decide whether or how to call it.

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

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

Schema description coverage is 100%, so the baseline is 3. The main description adds no parameter-level meaning and does not clarify which of the nine optional parameters actually influences the result, such as 'zone' versus the others described as discarded. It therefore stays at baseline rather than adding value.

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

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

The description is a noun phrase ('Common IANA timezone names for clock calls') that largely restates the tool name ('iana-zones') rather than stating an action like returns, lists, or validates. It adds 'common' and 'clock calls' as context, but an agent still cannot tell whether the tool returns a list of zones, validates a zone, or resolves aliases.

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 timezone, utc-time, or calc-eval. The phrase 'for clock calls' hints at a use case, but there are no conditions, exclusions, or alternative tool references.

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 are absent, so the description carries the full burden. It discloses the fetch and return behavior but omits that most parameters are discarded (as stated in schema) and any error/timeout behavior. The description does not contradict annotations (none exist) but is silent on important 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?

Single sentence, no filler, front-loaded with the action. It is appropriately brief but could be slightly more descriptive without losing 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 9 parameters, no output schema, and no annotations, the description is severely inadequate. It fails to explain how to specify the robots.txt URL, what 'group counts' means, or the role of the other 8 parameters. An agent cannot reliably invoke this tool from the given description alone.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds no parameter-specific meaning; it doesn't clarify which param is the URL to fetch or how the other params relate. Since the schema already documents each param, the description adds no incremental value.

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

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

States a clear action (fetch robots.txt) and result (group counts only), but does not specify which parameter supplies the target URL. The schema lists 9 generic params, none obviously tied to robots.txt, so an agent cannot map the description to a concrete invocation.

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 siblings like fetch-status or domain-shape. No exclusions, no alternatives mentioned.

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

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

With no annotations, the description carries the full behavioral burden. It only says the key is discarded, which hints at non-retention, but it does not describe return values, error behavior, whether the check is a simple regex, or whether any external access occurs. The schema's per-parameter 'discarded' notes already convey much of the same 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?

Two short, front-loaded sentences contain no filler. The second sentence adds a useful privacy note, though the description could have used the space more effectively to clarify the input mapping and expected output.

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 validator with no output schema and no annotations, the description omits critical operational details: what a valid Jira issue key looks like, which parameter to populate, and what the tool returns. This incompleteness is especially costly given the many sibling shape and validation 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?

The schema has nine optional parameters, but none is named 'key' or described as a Jira issue key. The parameters are generic (Git ref, URL, city, JSON, path, zone, query), so the description's 'Jira issue key' cannot be mapped to any parameter with confidence. The high schema-description coverage does not help because the descriptions are unrelated to the tool's stated purpose.

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

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

The description states a specific action and resource: checking the shape of a Jira issue key. This distinguishes it from sibling shape tools like github-repo-shape and figma-url-shape. However, it does not define what a valid Jira key shape is or how the key is supplied, so it is not fully self-contained.

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

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

No guidance is provided for when to use this tool versus alternatives such as github-repo-shape, domain-shape, or figma-url-shape. The tool name implies the domain, but the description offers no explicit selection criteria, exclusions, or context about when the check 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 must carry the full behavioral burden. It only mentions 'Body discarded,' which is a minor detail. It doesn't disclose side effects, permissions, error behavior, or what the HTTP status means. No information about the tool's actual execution beyond that.

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, but that is under-specification, not conciseness. For a tool with 9 parameters and no annotations, a single sentence is inadequate. The structure offers no progressive disclosure—no headers or breakdown of behavior.

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's complexity (9 optional parameters, no output schema, no annotations), the description is woefully incomplete. It doesn't explain the purpose beyond a vague 'library docs' phrase, doesn't cover the parameters, and gives no sense of return values or failure modes. An agent cannot confidently call this tool.

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

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

Schema coverage is 100%, so the schema documents each parameter, but the description completely ignores them and doesn't explain how they relate to the stated purpose. The mismatched parameters (city, zone, json) are not tied to 'library docs URL,' so the description adds confusion rather than clarity. It doesn't help an agent understand 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 says 'HTTP status for a public library docs URL' but the schema includes 9 unrelated parameters (city, timezone, JSON, etc.) with no connection to library docs. This is misleading—an agent would be confused about what the tool actually does. It fails to define a clear scope matching 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 guidance on when to use this tool versus any of the 28 siblings like fetch-status, web-fetch, or normalize-url. The description gives no context, exclusions, or alternatives. An agent has no basis to select this tool over others.

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 that values are discarded, but does not state what happens with invalid JSON, what the return value is, or how the other eight parameters affect the behavior. The minimal disclosure is inadequate for a tool with many optional parameters.

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

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

The description is short but under-specified. While it is front-loaded with the primary action, it omits essential information about usage and parameter mapping. The brevity is not a virtue here; it results in an incomplete and unhelpful tool definition.

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

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

The tool has 9 optional parameters, no required ones, and no output schema. The description only covers the core function without explaining the role of the other parameters, expected input format, return value, or error behavior. This is severely incomplete for an agent 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%, but the tool description adds no meaning beyond the schema. The parameter 'json' is described as 'JSON text to validate; discarded after the check', which contradicts the tool's stated purpose of counting keys. The description fails to clarify which parameter carries the JSON object, and the schema descriptions are inconsistent with the tool's behavior.

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

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

The description states a specific verb and resource: 'Count keys in a JSON object.' It clearly distinguishes from siblings like validate-json or domain-shape, but it does not clarify how the JSON object is passed via the parameters, leaving ambiguity about which parameter to use. The core purpose is clear but not fully actionable.

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. It does not mention conditions for use, exclusions, or sibling tools. An agent is left to infer the appropriate context from the name alone, which is insufficient.

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 the key behavior of dropping query and fragment, which is useful. However, the schema lists nine optional parameters with descriptions unrelated to URL normalization (e.g., 'city', 'feed', 'zone'), and the description does not clarify that only the 'url' parameter is actually used or that all others are ignored. This discrepancy between the description's narrow scope and the schema's broad surface creates confusion rather than 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, efficient sentence that front-loads the primary output and the dropping behavior. It wastes no words. However, it could have briefly noted that only the 'url' parameter matters, which would have improved clarity without adding much length. Still, it is appropriately concise.

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

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

Given the tool's complexity (a simple URL normalization) and lack of output schema, the description is mostly adequate for the core behavior. But the schema's nine optional parameters with unrelated meanings are not explained, and the description does not indicate that most are ignored. This is a significant completeness gap: an agent could reasonably assume the tool accepts and uses multiple inputs. There is also no mention of return format beyond 'origin, host, path' or error behavior for invalid URLs.

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 documented in the schema. The description adds no additional parameter semantics; it only mentions 'a URL' without specifying which parameter. Since the schema already covers each parameter, the baseline of 3 applies. The description does not compensate for the schema's irrelevant parameters, but it does not need to given high coverage.

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

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

The description clearly states the tool's function: 'Return origin, host, and path for a URL. Query and fragment are dropped.' This is a specific verb-resource pair and distinguishes it from siblings like fetch-status or validate-json. However, it does not explicitly name alternative tools or edge cases that separate it from similar URL-handling tools such as 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?

No guidance is given on when to use this tool versus any of the 25 siblings. The description does not mention scenarios where normalization is preferred over other URL-checking tools, nor does it state any prerequisites or typical use cases. This leaves the agent to infer the appropriate 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?

No annotations are provided, so the description must carry the full burden. It only discloses that no browser is launched, but gives no information about side effects, network activity, error behavior, or how the diverse parameters are processed. The mention of 'shape check' in the schema is unexplained.

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 brief (one sentence), which is concise, but it omits essential context needed for correct usage. Being short is not conciseness when critical information is missing.

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 parameters, no output schema, and no annotations, the description is grossly incomplete. It fails to explain the tool's actual functionality, how parameters interact, what the result format is, or any prerequisites. An agent would not know how to call this tool correctly.

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

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

The schema descriptions are complete (100% coverage) and self-explanatory for each parameter, so the description adds no extra meaning. However, the tool description implies a single URL-focused purpose that conflicts with the unrelated parameters, making the parameter semantics confusing rather than helpful.

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

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

The description states a specific action ('Check whether a URL can be opened'), but the input schema includes nine parameters (city, feed, json, path, zone, query, etc.) that have no obvious connection to URL checking. The tool's actual scope is ambiguous—either it does more than the description claims or the schema is misleading.

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

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

No guidance is provided on when to use this tool versus siblings like browser-url-ok, normalize-url, or fetch-status. The description offers no context about selection criteria, exclusions, or alternatives.

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

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

With no annotations, the description carries full behavioral burden. It discloses that the query is discarded, but does not explain behavior for the other parameters, the return value, or side effects. The schema descriptions mention discarding for each parameter, but the tool description only covers the query.

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

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

The description is a single sentence, which is concise, but it is too sparse to be helpful. It lacks essential details such as which parameter to use and what the output is, so the brevity works against 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?

The tool has 9 optional parameters and no output schema, yet the description does not explain the return format, which parameter is relevant, or how to handle the extraneous fields. An agent would struggle to call this correctly without additional inference.

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

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

Schema coverage is 100% with each parameter having a description, so the baseline is 3. The tool description adds no extra meaning beyond what the schema already provides; it does not clarify which parameter is the primary input or how the others relate to the described action.

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 'Count characters in a search query' with a specific resource, but the schema exposes 9 unrelated parameters (ref, url, city, etc.) that are not mentioned in the description, creating ambiguity about whether the tool accepts any of these or only 'query'. It does not distinguish itself from siblings like memory-key-count or hn-front-count.

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

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

No guidance is given on when to use this tool versus alternatives such as memory-key-count or calc-eval. The description does not specify that this is only for search query strings or that other tools should be used for other input types.

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, but it only states it's a 'short catalog'. It does not indicate whether the tool makes network calls, performs validation, or has side effects, despite parameters like url and host implying some external interaction. This is a significant transparency gap for a tool with no structured behavioral hints.

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

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

The description is a single short sentence, which is concise and free of fluff. However, it is underspecified and not front-loaded with actionable details; it reads more like a placeholder than a guide. The brevity does not earn credit when it omits critical 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?

For a tool with 9 parameters, no output schema, and no annotations, the description is grossly incomplete. It fails to explain what the tool does with the inputs, what it returns, or any constraints, making it nearly impossible for an agent to invoke it correctly without further investigation.

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 provides descriptions for all 9 parameters with 100% coverage, so the baseline is 3. The description adds no additional meaning about how parameters relate to the catalog or how they should be used, so it neither improves nor worsens the schema's own documentation.

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 provides a catalog of HTTP status codes, which identifies the resource and general action. However, it doesn't explain how the 9 unrelated parameters (e.g., url, city, json) are used, nor does it differentiate from siblings like fetch-status or normalize-url, leaving the purpose partially 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?

No guidance is given on when to use this tool versus alternatives. The description does not mention any conditions, exclusions, or related tools, so an agent cannot determine if this is the appropriate choice among the many sibling tools.

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

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

No annotations are provided, so the description must carry the full burden. It mentions 'Prompt discarded' and each parameter description notes that inputs are discarded, implying the tool ignores its inputs. However, this is not clearly explained in the main description, and the tool does not state whether it has side effects, requires authentication, or returns anything beyond the template. The behavior is only hinted at through scattered parameter notes.

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

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

The description is a single sentence, but it is under-specified rather than appropriately concise. It omits essential information such as what the template looks like, how it should be used, and what 'Prompt discarded' means. The brevity does not earn its place because it fails to convey the tool's behavior.

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, no output schema, and a one-sentence description, the information is completely inadequate. An agent cannot determine what the three-step template contains, how to format inputs, whether outputs are structured, or what the tool is actually for. The description is far too sparse to support correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents each parameter's type and note about being discarded. The main description adds no additional meaning beyond the schema; it merely repeats the discard concept with 'Prompt discarded.' It does not clarify why nine parameters exist if they are all ignored, nor how the parameters relate to the returned template. This adds confusion rather than value.

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

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

The description states a clear action ('Return a three-step thinking template') and names the resource (a template). However, it is vague about what the template contains and does not differentiate from any of the 26 sibling tools, several of which might also return structured output. It is not a tautology, but it lacks specificity.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention any conditions, prerequisites, or exclusions. The sibling tools include many utilities (e.g., calc-eval, validate-json, normalize-url), but no comparison or selection 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?

With no annotations provided, the description must disclose behavior. It only says 'Current time' and does not mention that only the 'zone' parameter is used while the other eight parameters are discarded, nor does it state the return format, network requirements, or any side effects. This is a major gap given the tool's actual parameter surface.

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 wasted words, which is good for conciseness. However, it is so minimal that it under-specifies the tool's actual behavior, but that is more a completeness issue than a conciseness issue. Structurally, it is front-loaded and easy to parse.

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

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

Given the tool has 9 parameters, no output schema, and no annotations, the description is grossly insufficient. It only addresses one parameter and gives no information about return values, error conditions, or why the other parameters are present. An agent cannot confidently invoke this tool correctly based on the description alone.

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

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

Schema coverage is 100% (each parameter has a description), so the baseline is 3. The description adds no additional meaning beyond the schema; it only reinforces that 'zone' is an IANA timezone name. It does not clarify why the other parameters exist or that they are ignored, which would be valuable, but the schema already documents their individual roles.

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, which is a specific verb-resource pairing. It is distinguishable from siblings like 'utc-time' (which likely gives UTC) and 'iana-zones' (which lists zones), so purpose clarity is strong.

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

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

No guidance is given on when to use this tool versus alternatives such as 'utc-time' or 'iana-zones'. There is no mention of conditions that would make this tool preferable, nor any exclusion 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 must carry full behavioral disclosure. It only states the output and gives no indication that the 9 parameters are largely ignored or that this is effectively a shape-check utility. It also does not mention side effects or constraints.

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

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

The description is extremely concise — a single phrase — which is front-loaded, but it is under-specified. It lacks structure and substantive content, failing to earn its place as a helpful definition.

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

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

With 9 parameters, no output schema, and no annotations, the description is far too sparse. It does not explain the output format, parameter usage, or behavior, 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 coverage is 100%, but the tool description does not connect the parameters to the output. The schema notes some parameters are discarded, yet the description gives no context, leaving the agent confused about why 9 unrelated parameters exist and how they should be used.

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 core purpose — returning the current UTC timestamp — but it is terse and ambiguous. It does not specify the format (e.g., ISO, epoch) nor differentiate from sibling tools like 'timezone', leaving the agent to guess the exact behavior.

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

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

There is no guidance on when to use this tool versus alternatives such as 'timezone' or 'calc-eval'. No conditions, exclusions, or context for selection 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 must carry the full burden of behavioral disclosure. It only says 'The body is discarded,' which is a small behavioral trait, but it fails to mention side effects, return format, error behavior, or why the schema has nine parameters when the tool is ostensibly about JSON. The lack of clarity on how the other parameters are used is a significant transparency gap.

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

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

The description is extremely short—one sentence—which is concise but not appropriately sized for a tool with 9 parameters and no annotations. It is under-specified rather than efficient. There is no structure or front-loading of critical information, and the sentence fails to earn its place because it omits essential context.

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

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

Given the tool has 9 parameters, no required fields, no output schema, and no annotations, the description is severely inadequate. It does not explain what the tool returns, how invalid JSON is handled, why the unrelated parameters exist, or what the user is expected to pass. An agent cannot correctly invoke this tool based on the description alone.

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

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

Schema description coverage is 100%, so the baseline is 3. The parameter descriptions do add some meaning (e.g., 'discarded after the shape check'), but the tool description itself adds no value beyond the schema. It does not clarify the relationship between the many parameters and the JSON validation purpose, leaving agents to guess how to populate them.

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

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

The description states a clear verb+resource: 'Check whether a body is valid JSON.' This is specific enough to identify the primary purpose. However, it does not differentiate from sibling tools like domain-shape or github-repo-shape, and the schema includes many unrelated parameters (url, city, feed, host, etc.) that are not mentioned, creating potential confusion. The description names the action but not the boundaries.

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, no conditions, no mention of when not to use it. The description simply states what it does without contextualizing its place among the 27 siblings. An agent must infer usage from the name alone.

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

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

No annotations are provided, so the description must carry the full burden. It states the operation is read-only implicitly but does not disclose that only the 'city' parameter is used while others are ignored (though the schema hints at discarding). It does not mention rate limits, API behavior, or whether the result is a simple string or structured data. This is a significant gap for an API call.

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

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

The description is a single, concise sentence with no filler words. It front-loads the primary action. However, it is almost too terse, omitting necessary context, but for conciseness it earns a high score because every word is purposeful.

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 output schema, and many siblings, the description is incomplete. It does not explain why so many parameters exist, which one is required, or what the return format looks like. The lack of differentiation from siblings and the absence of behavioral details make it insufficient for an agent to call correctly without inspecting the schema and making assumptions.

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

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

Schema description coverage is 100%, so each parameter has a description, giving a baseline of 3. The tool description does not add meaning beyond the schema; it only mentions 'city' without elaborating. It does not clarify which of the nine parameters are relevant, which could confuse an agent. The schema descriptions do compensate for some missing guidance, but the description itself adds no extra semantic value.

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

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

The description states a clear action (get current temperature) with a specific resource (a city) and source (Open-Meteo). It is not a tautology and conveys the primary function. However, it does not differentiate from sibling tools like 'geo-hint' or 'lib-docs-hint' which might have overlapping context, though the weather scope is distinct.

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. It does not mention exclusions or prerequisites. The description implies usage for temperature queries but does not clarify when to prefer other sibling tools like 'geo-hint' or 'utc-time'. No 'when not to use' is provided.

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

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

With no annotations, the description carries the burden and does disclose one important behavior: the body is discarded, so callers should not expect content. It does not disclose output format, side effects beyond a network fetch, or that the schema accepts many non-URL parameters such as city, json, path, and zone.

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 are front-loaded with the core behavior and a useful boundary. It earns a 4 for being concise, though it is arguably too terse for a nine-parameter tool with no output schema.

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

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

The description is incomplete for the actual complexity: it has no output schema, no annotations, nine optional parameters, and the schema includes non-URL inputs that are never explained at the tool level. An agent cannot reliably infer how city, feed, json, path, zone, and query relate to the HTTP status/content-type 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 each parameter has its own description and the baseline is 3. The tool description adds no parameter-level detail, but the schema's per-field explanations like 'discarded after the check' and 'no disk access' carry that burden.

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 core output: HTTP status and content type for a public URL, with the body discarded. This gives an agent a specific resource and result, though it does not distinguish it from siblings 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 phrase 'for a public URL' implies when to use it, and 'Body discarded' is an exclusion suggesting it is not the tool for retrieving page content. However, no alternative tool is named and there is no explicit when-not-to-use guidance relative to the many sibling tools.

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

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

No annotations are provided, so the description carries the full burden. It mentions 'Title discarded after the call,' implying no persistence, but no parameter is named 'title'—a mismatch. It does not disclose side effects, permissions, return format, or how other parameters are handled. For a tool with zero annotation coverage, this is insufficient.

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

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

The description is very short (two sentences) but the second sentence about 'Title discarded' is confusing because no parameter is called 'title.' The brevity is not backed by completeness; it under-specifies the tool's actual interface. The structure is not front-loaded with the most critical info, since the parameter-to-title mapping is missing.

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 required fields, no output schema, and no annotations, the description should explain how to invoke the tool and what it returns. It fails to do so. The agent cannot determine which parameter holds the Wikipedia title, what the tool returns, or any error conditions. This is inadequate for correct usage.

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

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

Schema description coverage is 100%, so the baseline is 3. The schema descriptions for each parameter (e.g., 'Git ref name; discarded after the shape check') already provide meaning. The tool description adds nothing about parameters, so it neither helps nor hurts beyond the schema.

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

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

The description clearly states the tool's purpose: 'Check whether a Wikipedia title exists.' This is a specific verb-resource pair that distinguishes it from sibling tools like browser-url-ok (URLs) and file-path-ok (files). However, the description does not indicate which parameter corresponds to the title, leaving a gap in execution.

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. It neither names any sibling tool nor gives context for choosing this over others like search-query-len or normalize-url. The agent must infer usage from the name and purpose alone.

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