vega

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

With no annotations provided, the description is the only behavioral disclosure. It usefully states that decoding yields both text and hex output, but it does not mention behavior on invalid Base64, whitespace, URL-safe encoding, or padding issues.

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

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

The description is one short sentence that front-loads the operation and adds the key output detail without filler. Every word earns its place for this simple utility.

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 single-string utility with an output schema, the description covers the core behavior and result format. It omits edge-case behavior like invalid input handling, but the tool's low complexity makes this a reasonably complete definition.

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's single parameter 'data' has 0% description coverage, and the tool description adds no meaningful detail about the expected input format. The meaning is inferable from the operation name, but the description itself does not compensate for the schema gap.

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 ('Base64-decode') and its result format ('returns text + hex'), making the tool's purpose unambiguous. It does not explicitly reference sibling tools such as base64_encode, but the decode verb and output format make the distinction evident.

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 only implied by the name and description: use this tool when you need to decode Base64 data. There is no explicit when-to-use guidance, no when-not-to-use note, and no alternative tool is 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 provided, the description carries the full burden of behavioral disclosure. It only states the raw operation without specifying input character encoding (e.g., UTF-8), output padding, line-breaking behavior, or error handling. This is insufficient for an agent to predict how the tool behaves on edge cases or non-ASCII 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?

The description is a single terse sentence with zero wasted words. It is front-loaded with the core purpose, but the extreme brevity sacrifices the behavioral and contextual detail needed for safe and correct invocation.

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?

While an output schema exists, so return format may be covered there, the description still lacks essential context for a tool with no annotations. It does not specify the base64 variant (standard vs. URL-safe), whether padding is included, or how it relates to sibling encoding tools like url_encode. The description is not complete enough for an agent to confidently handle all correct invocations.

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

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

The description implies that the parameter 'text' is the input to be encoded, but adds no further semantics. With schema description coverage at 0%, the description does not compensate by explaining expected input formats, such as whether Unicode is supported or whether whitespace is preserved.

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 'Base64-encode text' states a specific operation (encode) on a specific resource (text) using the base64 algorithm, which clearly distinguishes it from the sibling tool base64_decode. The purpose is unambiguous and immediately 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?

No guidance is provided on when to use this tool versus alternatives. It does not mention that base64_decode is the inverse for decoding, nor does it contrast with url_encode for URL-safe encoding. The agent must infer usage from the tool 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 carries the full burden of behavioral disclosure. It only says a number is converted; it does not mention accepted value formats, handling of invalid characters, base restrictions beyond 2-36, or any edge cases.

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, making it easy to parse. It is concise, though it could be slightly more informative without losing its economic structure.

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

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

For a three-parameter conversion tool with no annotations and no schema descriptions, this description is too minimal. While an output schema exists, the lack of input parameter guidance and behavioral details leaves significant gaps for correct invocation.

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

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

Schema description coverage is 0%, and the description does not explain the three required parameters (value, from_base, to_base). It adds only the general constraint that bases are between 2 and 36, which does not compensate for the absence of 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 verb ('Convert') and resource ('a number between bases 2-36'), which clearly identifies the tool's core function. It also implicitly distinguishes itself from base64 and fixed-text conversion siblings by limiting to bases 2-36, though it does not name any alternative.

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

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

There is no guidance on when to use this tool versus siblings like hex_to_text, text_to_hex, or base64_encode. The only implicit context is the base range 2-36, so the agent is left to infer when this converter 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?

There are no annotations, so the description carries the behavioral burden. It clearly states the core transformation behavior and lists the supported case formats, but it does not describe edge-case handling such as delimiter detection, acronym preservation, whitespace handling, or error behavior for invalid input.

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

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

The description is a single sentence with no filler. It is front-loaded with the action and immediately provides the specific format choices, so every word contributes to the agent's understanding.

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 two-string parameter tool with an output schema, the description plus schema is mostly sufficient for correct invocation. It lacks detail on edge cases, but the low complexity means this is not a major 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 0% and there are no enums, so the description is the only source of parameter semantics. It adds real value by listing the valid values for 'to', which is essential. It does not separately explain 'text', but that parameter's purpose is self-evident given 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 states a specific verb and resource ('Convert case') and enumerates the exact target formats: camel/snake/kebab/pascal/title/upper/lower. This clearly distinguishes it from sibling converter tools like base64_encode, hash, or url_encode.

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

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

Usage is implied: use this tool when a string needs to be converted to one of the listed case styles. However, there is no explicit guidance on when not to use it or which sibling tools might be better suited for related text transformations.

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 states the core operation clearly ('explain a cron expression') and implies a non-mutating, pure utility, but it does not disclose validation behavior, handling of invalid input, or what the explanation contains.

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. The action ('Explain') and the object ('a 5-field cron expression') are front-loaded, and 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 one-parameter utility with an output schema present, the description provides enough information to call it correctly: provide a string that is a 5-field cron expression. It lacks examples and error-handling details, but these are less critical given the simple interface and the existence of an output schema.

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 0%, so the description must compensate. It adds meaningful context by identifying the single required parameter expr as a 5-field cron expression, but it does not specify field order, delimiters, allowed values, or an example format, leaving the parameter partially under-specified.

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 ('Explain') and a specific resource ('a 5-field cron expression'), making the tool's basic function clear. It is easily distinguishable from the listed sibling utilities by topic, though it does not explicitly name an alternative or define what 'explain' produces.

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

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

No explicit when-to-use or when-not-to-use conditions are given, and no sibling alternatives are mentioned. However, the use case is implied: pass a 5-field cron expression when you need it explained, which is sufficient given that none of the sibling tools overlap with cron functionality.

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 burden. It discloses that the tool performs a conversion and returns UTC plus relative output, which is useful. However, it does not clarify whether the epoch is seconds or milliseconds, how invalid inputs are handled, or what timezone basis underlies the 'relative' component.

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 that front-loads the action and output form. Every phrase contributes to understanding, with no filler or redundant restatement of the tool name.

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

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

For a one-parameter conversion tool with an output schema, the description is mostly adequate, but it omits the epoch unit (seconds vs milliseconds) and any behavior on invalid input. Since there are no annotations to fill these gaps, the agent may not reliably handle common edge cases.

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 0%, so the description must compensate for the undocumented ts parameter. It identifies ts as a unix epoch but does not specify expected format, string representation, or unit. This adds some meaning beyond the bare schema but leaves critical ambiguity.

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 and resource: convert a unix epoch value into a human-readable UTC representation plus a relative form. This is easily distinguishable from sibling tools like now or cron_explain, and the title is not merely repeated.

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 alternatives such as now for current time or cron_explain for scheduling syntax. There is no context about prerequisites or exclusions, 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 burden of behavioral disclosure. It does add useful behavioral detail by listing the allowed algorithm values (md5/sha1/sha256/sha512), which are not captured as enums in the schema. However, it does not state the output form (e.g., hex digest) or other traits; the output schema may cover return values, but the description itself is thin.

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

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

Two sentences with no filler: the verb and resource come first, followed by the algorithm choices. Every word contributes to the caller's understanding, making this an appropriately sized description for a simple tool.

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

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

For a straightforward two-parameter hashing utility with an output schema, the description covers the essential purpose and parameter values. It is not exhaustive (e.g., no mention of output encoding or algorithm case sensitivity), but given the tool's simplicity and the presence of an output schema, it is adequately complete.

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

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

Schema description coverage is 0%, so the description must compensate. It does so by naming the algorithm options for 'algo' and indicating that 'text' is the string to hash. This gives an agent enough semantic information to populate both required parameters, though it could be more explicit about text's role.

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 ('Hash') and resource ('a string'), and it enumerates the supported algorithms, which makes the operation unambiguous. It does not explicitly differentiate from sibling tools, but none of the siblings perform hashing, so the purpose is clear.

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

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

The description implies the usage context: hash a string using one of the listed algorithms. However, it provides no explicit guidance on when to prefer this tool over alternatives or any exclusions or prerequisites, 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?

No annotations are provided, so the description carries the full burden for disclosing behavior. 'Decode hex bytes to text' only restates the core operation, but does not explain input format expectations, invalid hex handling, whitespace/0x prefixes, or the text encoding produced. This is more than a tautology but provides minimal behavioral depth.

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 and every word contributes semantic value. It is appropriately concise for a simple one-parameter tool.

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

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

The tool is simple and has an output schema, so an agent can infer the return shape. However, the critical input format rules for the hex parameter are left undocumented at 0% schema coverage, which is a meaningful gap for correct invocation. It is adequate only if the agent already knows the convention.

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 0%, so the description must compensate for the bare 'hex' string parameter. It adds only 'hex bytes' as a semantic hint and does not specify allowed formats, separators, case sensitivity, or whether prefixes like '0x' are accepted. At 0% coverage, this is insufficient.

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 ('Decode'), names the resource ('hex bytes'), and gives the result ('text'). This makes the operation unambiguous and distinguishes it from inverse or related siblings like text_to_hex, while also differentiating it from base64_decode and url_decode.

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 states what the tool does but gives no guidance on when to choose it over siblings such as text_to_hex, base64_decode, or url_decode. There is no explicit 'use this when...' or mention of exclusions, so an agent must infer usage entirely from the tool name and one-line description.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'Decode HTML entities,' without specifying whether it handles named, numeric, or invalid entities, or how it deals with edge cases. This is insufficient for an agent to predict behavior confidently.

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 unnecessary words. It is appropriately front-loaded with the core action. However, it may be too sparse to fully inform the agent, but for conciseness it is well-structured.

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

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

Given the tool's simplicity, the description is somewhat adequate, but it lacks context about the output format (though an output schema exists) and any limitations or examples. For a tool with one parameter and a clear purpose, this is minimally acceptable but leaves room for improvement.

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 zero description coverage for the 'html' parameter, and the description does not explain what the parameter represents. Although the tool name implies the parameter is an HTML string, the description should explicitly state that the input is the HTML content to decode. It adds no semantic value 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 states a specific verb and resource: 'Decode HTML entities.' This clearly differentiates from sibling tools like base64_decode and url_decode by specifying the entity type. The purpose is unambiguous.

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

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

The description provides no guidance on when to use this tool versus other decode tools. There is no mention of typical use cases, such as when a string contains HTML entity references, nor any exclusions. The 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions output categories but does not state that inputs must be valid JSON strings, what happens on invalid input, how nested structures or arrays are handled, or whether the operation has side effects. This is a meaningful transparency gap for a 2-parameter tool.

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

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

The description is a single, front-loaded sentence with no filler words. It is efficient and easy to scan, though it omits important parameter details that would justify a 5.

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?

An output schema exists, so return values do not need to be described, but the input semantics are under-specified and there is no annotation coverage. For a tool with two required parameters and 0% schema description coverage, the description is not complete enough to guarantee correct invocation on the first attempt.

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 0%, so the description must compensate. It only calls the inputs 'two JSON values' and never clarifies that a and b are expected as serialized JSON strings, or what validity constraints apply. An agent would have to guess how to populate these parameters correctly.

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

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

The description uses a specific action ('Diff') and a clear resource ('two JSON values'), and it states the kind of result (added/removed/changed keys). This distinguishes it well from the encoding and formatting siblings, though it does not explicitly contrast with any sibling tool.

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, nor are there any prerequisites or exclusions. The intended use case—comparing two JSON values—must be inferred from the purpose statement 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 carries the full burden of behavioral disclosure. It states the validate and pretty-print operations but does not mention what happens on invalid JSON (error vs. fallback), whether whitespace/indentation is configurable, or side effects (none expected).

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, front-loaded with the core actions. Every word earns its place, and there is no filler or redundant repetition of the title.

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 one-parameter utility with an output schema, the description is close to sufficient: it names the operation and the input. However, it omits error-handling behavior and any constraints on the input string, which an agent would need to anticipate failures 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 0%, so the description must compensate. The phrase 'Validate + pretty-print JSON' implies the 'json' parameter is the JSON string to process, which aligns with the schema. However, it adds no detail about expected format (e.g., stringified JSON), size limits, or special handling.

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 validates and pretty-prints JSON, using a specific verb and resource. It does not explicitly differentiate from siblings like json_diff or json_to_csv, but the action is distinct enough that an agent can infer its 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?

No guidance is given about when to use this tool instead of alternatives. The description does not mention scenarios such as 'use when you need to check JSON validity or format it for readability' or exclude cases like diffing or converting JSON.

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 does add a meaningful behavioral trait by saying 'flatten,' which suggests nested objects are handled, but it does not disclose how ragged arrays, missing keys, or invalid JSON are treated.

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

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

A single sentence with no filler. The core transformation, input shape, and output format are all front-loaded and presented 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?

This is a simple one-parameter transformation tool with an output schema present, so the description need not explain return structure. The main missing context is edge-case behavior, but for a basic utility the description is reasonably complete.

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

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

The schema only describes 'json' as a string with no explanation, so the description must compensate. It does by specifying that the value must be a JSON array of objects. This adds real semantic meaning beyond the bare schema type.

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 ('Flatten') and a precise input-to-output transformation: JSON array of objects to CSV. This is enough to distinguish it from sibling tools like json_format, json_diff, and base64_decode.

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 by the transformation phrase, but no explicit guidance is given about when to choose this tool over alternatives or what input shapes are unsupported. However, among the listed siblings there is no close CSV alternative, so the context is mildly helpful.

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 behavioral traits on its own. It does mention the most important limitation (no signature verification) and implies it decodes both header and payload. However, it does not disclose error behavior for invalid tokens, whether it validates the token structure, or any other constraints. The description covers the primary caveat but leaves other potential behaviors undocumented.

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 that front-loads the action and includes the essential caveat. Every word earns its place; there is no fluff or redundant information. It is concise while conveying the core functionality and a critical limitation.

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 simplicity of the tool (one parameter, no nested objects) and the presence of an output schema (which likely details the return structure), the description covers the essential aspects. It explains what the tool does and its main limitation. It could add more about error handling or token validation, but for a simple decode operation, it is reasonably complete. The output schema likely fills in the return details.

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 zero description coverage, so the tool description must compensate. The description implies that the 'token' parameter is a JWT string, but it doesn't explicitly state the parameter's meaning or format. The single parameter is self-explanatory given the purpose, but the description adds minimal semantic value beyond the schema's type declaration.

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 (decode) on a specific resource (JWT header+payload) and adds a critical caveat (no signature verification). It clearly distinguishes this tool from the other encoding/decoding siblings like base64_decode or url_decode, which target different formats. The verb and resource 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 description implicitly communicates when to use this tool: when you have a JWT and need to inspect its header and payload without verifying the signature. The caveat 'no signature verification' tells the agent this is not for validation tasks, though it doesn't name alternatives explicitly. The usage context is clear enough for an agent to decide.

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 disclosure. It states the output is current unix time (UTC), implying a read-only operation, but does not explicitly mention that it is side-effect free, the exact format (e.g., seconds vs milliseconds), or any potential precision details. For a trivial tool this is adequate, but it leaves some ambiguity.

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, clear sentence that is front-loaded with the core meaning. It contains no unnecessary words and is perfectly sized for the tool's simplicity.

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 trivial nature (no parameters, a known output schema, and a single clear purpose), the description is complete. An agent can understand exactly what this tool does and how to invoke it without further elaboration.

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

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

The tool has zero parameters and the schema is empty with 100% coverage. Per calibration guidelines, the baseline for 0 parameters is 4, and there is no additional parameter information needed since none exist. The description does not need to compensate.

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

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

The description clearly states the tool returns current unix time, which is a specific resource and implied action. However, it does not differentiate from the sibling tool 'epoch' that might serve a similar or related purpose, so it misses the opportunity to distinguish itself.

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

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

There is no guidance on when to use this tool versus alternatives like 'epoch' or other time-related tools. No conditions, prerequisites, or exclusions are provided, leaving the agent to infer usage context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool returns matches and groups, but does not disclose regex flavor (e.g., PCRE, ECMAScript), flags support, error behavior for invalid patterns, or whether it returns all matches or just the first. This is a significant gap for a testing 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 concise sentence that front-loads the core action and return value. It is efficient, though it omits important behavioral details that would make it more useful.

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 an output schema, the return structure is covered, but the description lacks essential context: regex flavor, flags, error handling, and match semantics. For a tool with no annotations and 0% schema coverage, this is incomplete. An agent would likely need to inspect the output schema or experiment to use it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It names 'pattern' and 'text' implicitly via 'Test a regex', but does not explain the semantics of each parameter, such as what 'text' represents or how 'pattern' is interpreted. The description adds minimal meaning beyond the schema's field names.

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 'Test a regex; return matches + groups.' clearly states the verb (test) and resource (regex), and the return value (matches + groups). It distinguishes itself from the sibling tools, which are mostly encoding/decoding/formatting utilities, though it doesn't explicitly name an alternative.

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

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

No guidance is given on when to use this tool versus alternatives. The sibling list contains no other regex tool, so the intended use is implied, but there is no explicit context about when to choose this over, say, string_metrics or case_convert. The description does not state any 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 discloses the key transformations (lowercase, dashes, ascii), which is valuable, but it does not detail edge cases such as handling of spaces, punctuation, or Unicode input. This is a moderate level of transparency for a simple transformation 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, succinct sentence with zero waste. It front-loads the action and includes essential transformation details in parentheses. This is an ideal length for a simple utility tool.

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

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

For a tool with one parameter, an output schema, and no annotations, the description is nearly complete. It explains the core transformation and does not need to describe return values because the output schema exists. Minor gaps like edge-case handling could be added, but for its simplicity, the description is adequate.

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 0% description coverage, so the description must compensate. However, the description merely refers to 'text' without adding constraints or format details beyond what the parameter name implies. It does not explain expected input format, length limits, or how special characters are treated. The description adds minimal semantic value 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 verb 'Slugify' and the resource 'text', and specifies the transformation (lowercase, dashes, ascii). This distinguishes it from sibling tools like case_convert or url_encode, which have different purposes. The purpose is unambiguous and specific.

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

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

No explicit guidance is given about when to use this tool versus alternatives, nor any exclusions. The context implies it is for generating URL-friendly slugs, but this is not stated. The tool's unique name and description make usage somewhat obvious, but the dimension requires more explicit direction for a higher score.

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 is the only source for behavioral expectations. It states what is computed but not that the operation is side-effect-free, how edge cases (empty string, Unicode) are handled, or what format the entropy uses. This is acceptable for a pure string utility but does not fully carry the behavioral burden.

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 eight words and front-loads the complete set of outputs. Every element is informative, and there is no filler.

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

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

The tool is simple with a single string parameter and an output schema exists, so an agent can call it correctly from this description. The main gaps are parameter semantics and behavioral caveats, but these are minor for a pure text metrics utility.

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 0% and the description never references the 'text' parameter directly. It implies that metrics are computed from the provided string, but it does not clarify counting semantics such as whitespace, newline handling, or Unicode codepoints vs bytes.

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

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

The description identifies the tool's function as computing length, word, line, and character counts plus Shannon entropy. This makes the purpose clear and distinguishes it from the sibling encode/decode/convert tools, though there is no explicit verb such as 'computes' or 'returns'.

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

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

The metrics listed imply when the tool is appropriate: whenever an agent needs summary statistics of a string. However, it does not explicitly contrast usage with sibling tools or state when not to use it, so guidance is implicit rather than explicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states only the basic conversion, not how the input text is interpreted (e.g., UTF-8 vs ASCII), the exact format of the hex output (lowercase, uppercase, prefix, separators), or any reversibility implications. This leaves meaningful ambiguity for an agent invoking 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 with no filler or redundant content. Every word earns its place by identifying the action and the target format, making it appropriately sized for a simple conversion utility.

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 one-parameter converter, the description is minimally adequate, and the presence of an output schema reduces the need to describe return values. However, with no annotations and no mention of encoding assumptions or output formatting, the description leaves some correctness-relevant gaps. It is enough to attempt the call but not enough to guarantee the same result across all text inputs.

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

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

The schema has one required string parameter, `text`, with no property description and 0% schema description coverage. The tool description merely restates that text gets encoded, adding no detail about character encoding, input limits, or expected formatting. Because schema coverage is low, the description should compensate for the missing parameter documentation but does not.

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 ('Encode') and resource ('text to hex'), clearly indicating the operation. It also distinguishes this tool from the sibling hex_to_text by making the direction of conversion explicit. Even without reading the schema, an agent knows exactly what this tool 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 about when to use this tool versus alternatives like hex_to_text or base64_encode, and no exclusions are mentioned. The intended use must be inferred entirely from the tool name and the verb 'encode,' so the description provides no explicit routing 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 carries the full burden of behavioral disclosure. It only states the core transformation and does not disclose how plus signs are handled, whether UTF-8 decoding is applied, or what happens with malformed percent-sequences.

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 zero filler and the key operation 'Percent-decode' is front-loaded. It is appropriately concise for a simple utility, though the brevity leaves room for more behavioral detail.

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

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

For a one-parameter pure transformation with an output schema present, a short description can almost suffice. However, the lack of annotations, missing percent-decoding edge-case behavior, and absence of sibling-tool routing leave an agent with only partial context for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate for the parameter's meaning. The phrase 'a string' adds only minimal context that `data` is the percent-encoded input, but it provides no format constraints, examples, or caveats about expected input.

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

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

The description uses a specific verb and resource: 'Percent-decode a string.' This clearly distinguishes it from encode tools like url_encode and from other decoders by naming the percent-decoding method explicitly. It does not explicitly differentiate from sibling decoders like html_decode, but the percent-decoding term is specific enough.

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. It does not mention that it is suitable for decoding percent-encoded URL components, nor does it point to url_parse for full URL handling or base64_decode for other encoding schemes.

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. 'Percent-encode a string' states the basic action but does not disclose important behavioral details such as whether non-ASCII characters are UTF-8 encoded, whether spaces become %20 or +, or if reserved characters like '!' and '~' are encoded. An agent cannot predict the exact output format without external knowledge.

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. It is front-loaded and immediately communicates the core action, and there is no wasted text. It earns its place, though the brevity comes at the cost of missing behavioral details 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?

The tool is simple (one string parameter, output schema present), but the description leaves key ambiguity about the encoding algorithm. With no annotations and zero parameter coverage, the agent is missing guidance on what gets percent-encoded and how. The output schema exists but does not clarify the encoding rules, so the description is not complete enough for reliable invocation.

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

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

Schema description coverage is 0%, so the description must compensate for the single 'text' parameter. It simply says 'a string', which confirms that the parameter is the input string but adds no details about limits, allowed character sets, or how the encoded value relates to the output. The parameter name and type are already self-explanatory from the schema, so the description contributes minimal extra 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 states a specific verb ('percent-encode') and a resource ('a string'), making the operation clear. It is implicitly distinguished from siblings like url_decode and url_parse by the encoding focus, but it does not explicitly name alternatives or edge cases. Overall, an agent can tell what the tool does without opening 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?

There is no guidance on when to use this tool versus url_decode, url_parse, base64_encode, or other encoding tools. The description gives no context about appropriate scenarios, format expectations, or exclusions, leaving the agent to infer usage from the tool 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 present, so the description carries the full burden of disclosure. It honestly states the parsed output components, but it does not describe behavior on malformed URLs, normalization, ports, userinfo, or error handling. It is minimally transparent without being misleading.

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

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

One short sentence with the output components front-loaded. Every word earns its place, and the description achieves clarity with no filler.

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

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

For a single-parameter, side-effect-free parse operation, the description is nearly complete. The output schema exists, and the description already names the key output parts. It only lacks minor edge-case behavior, which is not critical for basic 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 has zero description coverage for the single `url` parameter, so the description must compensate. Saying 'Parse a URL' clarifies that the input is a URL string, but it adds no format details, examples, or edge-case guidance beyond what the property name already suggests.

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 precise imperative: 'Parse a URL into scheme/host/path/query/fragment.' It names the verb, the resource, and the observable output components, making the tool's role obvious and clearly distinct from siblings like url_decode and url_encode.

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 by the name and the component list, but the description does not explicitly tell an agent when to prefer this tool over related URL siblings or when not to use it. There are no exclusions or alternative routing statements.

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. It states the tool generates a random UUID v4, which accurately discloses its core behavior. It does not detail the output format, but the presence of an output schema likely covers that. The description is transparent about the randomness and version, which is sufficient for a simple generator.

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 unnecessary words. It is perfectly front-loaded, stating the action and result immediately. Every word earns its place, making it optimally 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 no parameters and an output schema available, the description is complete. It tells the agent exactly what the tool does, and there is no missing information that would hinder correct invocation. The context is fully sufficient for this simple operation.

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

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

The tool has zero parameters, and the input schema confirms this with an empty properties object. The description does not need to explain parameters, and the baseline of 4 is appropriate because there is nothing to document. No additional parameter semantics are required.

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 explicitly states the verb 'Generate' and the resource 'a random UUID v4', which is precise and specific. It clearly distinguishes this tool from all siblings, which are conversion/encoding utilities, by indicating the unique action of creating a UUID.

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?

While no explicit when-to-use guidance is given, the tool's purpose is self-evident and there is no sibling that competes for the same task. The description implies its use when a random UUID is needed, and with zero parameters it is trivially straightforward. However, it lacks an explicit statement about when not to use it, so it falls just short of a 5.

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