FabTally Utility Belt

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

Discloses the tool is deterministic and mentions a 400 error for different-dimension conversions, which adds behavioral insight beyond the absent annotations. However, output format and handling of invalid unit strings are unspecified.

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 compact yet information-rich: free usage, determinism, dimensions, args, examples, and an error behavior are all included without redundancy. The minor typo 'Different-dimension conversions 400' does not detract from clarity.

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

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

Given the straightforward 3-parameter tool with no output schema and no annotations, the description covers purpose, usage, examples, and one edge case. Return value format is not specified, but the intent is clear for this simple conversion tool.

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

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

The schema covers all parameters with short descriptions, but the description adds concrete examples (e.g., from:'c', to:'f', GiB to MB) that clarify unit notation and the numeric value type. This goes beyond the schema baseline.

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

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

Clearly states the tool converts a value between units in the same dimension and enumerates dimensions (length, mass, temperature, etc.). This specific verb-resource pairing distinguishes it from sibling tools like currency and datemath.

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?

Indicates usage for unit conversion across multiple dimensions, but does not explicitly state when not to use (e.g., currency conversions may be handled by the 'currency' sibling). The dimension list implies when to use, but exclusions are absent.

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 of behavioral disclosure. It discloses the paid nature ($0.001) and the x402 challenge behavior, which is essential for the agent to understand costs and required settlement. It does not detail output structure or error handling, but the payment behavior is well-covered.

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

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

The description is two sentences, front-loaded with the paid warning, and efficiently packs the purpose, parameter list, defaults, and payment behavior into a compact space. Every sentence contributes valuable information without redundancy.

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

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

For a paid tool with no output schema, the description covers the core purpose, parameters, and—critically—the payment challenge flow. It could benefit from describing the shape of the returned data, but the essential usage information is present, making it sufficiently complete for an agent to invoke the tool.

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

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

Schema coverage is 100%, with all five parameters described in the schema. The description merely summarizes the args and their defaults (e.g., 'timezone (IANA, default UTC)'), adding no extra meaning beyond what the schema already provides. Therefore, the baseline of 3 applies.

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

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

The description clearly states the tool's function: 'Parse a 5- or 6-field cron expression and return the next N run times plus a plain-English description.' This specific verb+resource pairing distinguishes it from siblings like rrule (RRULE expressions) and datemath (date arithmetic).

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 clear usage context, especially for the payment flow: 'Without payment returns the x402 challenge; pass x_payment to settle.' It does not explicitly mention alternatives, but the purpose is distinct enough that an agent would know when to use this tool versus siblings.

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

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

No annotations are provided, so the description carries the full burden, and it excels: it discloses the $0.001 cost, the keyless public feed, caching, mid-market/informational nature, and the x402 challenge/payment behavior. This gives the agent a clear picture of side effects and prerequisites beyond the name and schema.

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

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

The description is two dense sentences, front-loaded with the critical 'PAID $0.001' warning. Every clause adds information—source, rates, caveat, args, payment flow—with no filler or redundancy.

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

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

For a simple 4-param tool with no output schema or annotations, the description covers purpose, cost, data source, caching, limitation, and payment behavior. While it doesn't spell out the exact result payload, the conversion result is strongly implied, and the description provides enough for an agent to invoke and handle the payment dance 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 coverage is 100%, giving a baseline of 3. The description adds value by listing the args, giving concrete ISO-4217 examples (USD, EUR, JPY), and explaining the x_payment parameter's role in settling the challenge. This goes beyond the schema's field 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 opens with a specific verb+resource: "Convert an amount between currencies" and adds precision with reference/mid-market rates, ECB feed, and ISO-4217 codes. This clearly distinguishes it from the sibling 'convert' tool by scoping it to live currency conversion with a specific data source.

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

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

The description provides clear context: it is PAID, uses cached ECB rates, is informational, and not a dealable quote. It also explains the payment flow (x402 challenge without payment, settle with x_payment). However, it does not explicitly reference the sibling 'convert' tool or state when to choose one over the other, so it falls short of a full when/when-not/exclusion set.

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 explicitly reveals the paid nature ($0.001), the x402 challenge behavior, and the requirement to pass x_payment to settle. It also notes configurable weekend and holidays. The main gap is that it does not describe the return format for each operation, which would be important for an agent consuming the result.

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

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

The description is a single well-structured paragraph that front-loads the critical payment warning, then enumerates the four operations and their key parameters. Every sentence is substantive, with no filler or redundancy, making it easy to scan for relevant operation details.

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

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

The description covers the core logic (operations, payment flow) and the schema handles parameter documentation, but there is no output schema. The description does not specify the return value shape (e.g., a string for add/subtract, an object for diff), which is a notable gap for an agent that needs to interpret results. Overall, it is adequate for tool selection and basic invocation but not fully complete.

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

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

The input schema covers all 11 parameters with 100% description coverage, so the description adds little semantic value beyond what is already structured. It does mention the ISO-8601 duration format and operation-specific parameter groupings, but these are also present in the schema. Thus, 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 clearly identifies the tool as calendar date math and enumerates four distinct operations (add/subtract, diff, business-add, business-diff) with their respective inputs. This specific verb+resource pairing distinguishes it from sibling tools like timezone, cron, and rrule, making its purpose unmistakable.

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

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

The description gives concrete usage context by listing each operation and its required parameters (e.g., 'op='add'/'subtract' an ISO-8601 duration to a date'). It also explains the payment flow, guiding whether to expect a challenge or pass x_payment. However, it does not explicitly state when not to use this tool versus alternatives like diff or timezone, though the sibling context implies these are distinct.

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

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

With no annotations, the description carries the behavioral burden and does well by disclosing the paid nature, the x402 challenge fallback, the need to pass x_payment to settle, and default modes/context. It does not explicitly state side-effect-free behavior, but the read-only nature is clear.

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

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

The description is compact and front-loaded with the critical cost warning, then moves efficiently through output, arguments, and payment behavior. Every sentence contributes useful information 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?

Given the absence of an output schema and annotations, the description does a solid job covering return types, payment gating, and key parameters. It falls slightly short on elaborating label arguments and the exact structure of stats, but overall it is sufficiently complete for most use 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 71%, and the description adds value by condensing the argument list and explicitly noting defaults for mode and context. However, label_a/label_b are mentioned without explaining their meaning, so parameter semantics are not fully complete.

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 'Diff two texts' and enumerates concrete output forms (unified patch, structured op-list, stats), which distinguishes it from sibling conversion/encoding tools. The verb and resource are specific and unambiguous.

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

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

The intended use is implied through 'Diff two texts,' and the payment workflow is explicitly explained. However, there is no guidance on when to choose this tool over alternatives or any exclusion criteria, leaving usage context partial.

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 fails to mention output format, side effects, error handling, or whether the operation is reversible. The 'FREE' note is irrelevant and does not aid 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 short and front-loads the core purpose. However, 'FREE' is unnecessary and consumes valuable space. Overall, it is concise but could be tighter by removing the extraneous note.

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

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

For a simple tool, the description covers the operation modes and arguments. However, it does not describe the return value or any potential edge cases (e.g., invalid input). Given the absence of an output schema and annotations, more contextual details would be helpful.

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%, and the schema already describes 'op' and 'text' adequately. The description's 'Args: op, text' adds no new semantic value beyond what is in the schema, so the baseline 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 clearly states the tool's purpose with a specific verb ('Encode or decode') and resource ('text'). It also enumerates all supported operations, distinguishing it from sibling tools like 'convert' or 'hash'.

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

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

No guidance is given about when to use this tool versus alternatives. The description does not mention use cases, prerequisites, or exclusions. It only lists operations and arguments.

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 discloses key behaviors: free to use, supported algorithms, optional HMAC, output encodings, and the special 0x-form for keccak256. It does not detail error handling or restrictions beyond the schema's HMAC caveat, but for a pure compute tool this is reasonably transparent.

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

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

The description is compact and front-loaded with the key action and cost, using a few efficient sentences that cover algorithms, HMAC, encodings, and a special case. No wasted words or unnecessary repetition.

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

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

Given the tool's moderate complexity and absence of an output schema, the description covers the full range of behaviors: algorithm choices, optional HMAC, input/output encodings, and the Ethereum-friendly 0x form. It is sufficiently complete for an agent to invoke the tool correctly.

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

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

The input schema already describes all parameters with 100% coverage, so the description adds little beyond summarizing the parameter list. It restates the parameter names and output options but does not enrich semantics beyond what the schema provides, warranting the baseline score.

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 it computes cryptographic digests and lists all supported algorithms, distinguishing it from sibling tools like encode and convert. The verb 'compute' and resource 'cryptographic digest' are specific and 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 conveys the tool's purpose and options but does not explicitly state when to use this tool over alternatives such as encode or convert. Usage context is implied rather than directly contrasted.

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 that a CSPRNG is used and specifies a count limit of 1000, which is useful behavioral context. However, it doesn't mention return format, error behavior, or what happens with invalid kind values, leaving 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 extremely concise, front-loaded with 'FREE. Generate identifiers.' and then lists essential detail in a compact format. Every sentence contributes useful information, with no filler or repetition.

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

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

For a simple tool with no output schema, the description covers the main inputs and behavioral constraints, but it omits the return format (e.g., whether count>1 returns an array). This is a meaningful gap since the user would need to infer the output structure.

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 description adds value by clarifying parameter applicability: 'nanoid takes size; hex/base64url take bytes' and 'count up to 1000'. This goes beyond the schema's individual descriptions and helps the agent understand conditional parameter usage.

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 as 'Generate identifiers' and lists the supported formats (uuidv4/v7, ulid, nanoid, hex, base64url, int). This is a specific verb+resource combination that distinguishes it from sibling tools like convert, hash, or regex.

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 clear context on when to use this tool (any time identifiers are needed) and includes usage constraints like kind values and count limits. It does not explicitly mention when not to use it or reference alternative tools, but the purpose is unambiguous given the sibling set.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, and it does so well: it discloses the $0.001 cost, the x402 challenge behavior when payment is missing, and the promise of plain-English error explanations. It also mentions the args at a high level. It does not state whether the operation has side effects (it is inherently read-only), but this is implicit for validation.

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

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

The description is two sentences long, front-loaded with the critical payment warning, and then immediately states the core functionality. Every word serves a purpose: the cost, the validation behavior, the error explanation, the arguments, and the payment workflow are all covered. No fluff or redundancy.

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

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

For a paid tool with no output schema, the description provides sufficient context for an agent to select and invoke it: the validation target, the error explanation behavior, the cost, and the payment challenge/settle workflow. It does not describe the success-return format, but that is less critical given the lack of an output schema and the tool's clear functional scope.

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

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

The input schema already provides full descriptions for all three parameters, so the baseline is 3. The description adds a small amount of operational meaning by explaining x_payment's role in settling the payment and noting data can be any value. However, it does not add significant depth beyond what the schema already declares, so a 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 clearly states the tool's purpose: validating a value against a JSON Schema (2020-12) and explaining errors in plain English. This distinguishes it from the sibling tools (convert, encode, hash, etc.), which handle different operations. The verb 'validate' and the specific resource 'JSON Schema' make the purpose 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 clear context for when to use the tool: whenever JSON Schema validation with human-readable error explanations is needed. It also gives explicit usage guidance for the payment flow: omit x_payment to receive the x402 challenge, or include it to settle the call. It does not explicitly name alternatives, but no sibling offers validation, so the intended use is clear.

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 discloses catastrophic-backtracking protection, a killable worker with hard timeout, and 400 responses on pathological patterns, which is valuable safety context beyond the schema. It could add error behavior for invalid regex but is otherwise transparent.

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

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

The description is three sentences, front-loaded with 'FREE' and the main purpose. No wasted words; every sentence adds value.

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 simple tool, the schema covers all parameters, and the description adds safety behavior and operation modes. No output schema exists, so return format isn't required. Sibling tools are unrelated, so no additional disambiguation is needed.

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 already covers all six parameters with descriptions (100% coverage). The description adds the op value 'extract' and lists flags (gimsuy), but these are already implicit in the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool runs a regular expression against input with specific operations (test/match/extract/replace). The title reinforces this with 'Regex test / match / extract / replace (safe)'.

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

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

The description implies usage for regex operations but does not explicitly differentiate from sibling tools like 'text', which could also handle text manipulation. It does not provide when/when-not 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 provided, the description fully discloses the key behavioral trait: this is a PAID tool requiring an x402 payment, and without payment it returns a 402 challenge. It also notes default values for 'after' and 'count', and the timezone handling.

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

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

The description is dense but efficient, covering payment, purpose, parameters, and a tip in a compact format. Front-loads the PAID indicator. Slightly long but every sentence adds useful 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?

Given the tool's complexity (5 params, payment flow, no output schema), the description covers the essential context: what it does, default behavior, payment mechanism, and a usage tip. It does not specify the output format, but the phrase 'next N occurrences' adequately communicates the result.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value beyond the schema by showing an example RRULE string, explaining the x_payment forwarding behavior, and offering a tip about DTSTART. This enriches parameter understanding.

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 ('expand') and resource ('iCal RRULE (RFC 5545) recurrence') and defines the output ('next N occurrences'). It clearly distinguishes itself from sibling tools like cron or datemath by focusing on recurrence expansion.

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?

Provides practical guidance: a tip to include DTSTART for anchored series, and explicit instruction on handling the x402 payment challenge ('pass x_payment'). However, it does not explicitly contrast with alternative tools or state when not to use it.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It adds useful context like 'FREE' and explains the template placeholder mechanism, but it doesn't mention output format, error behavior, or strict mode handling. This is a moderate level of transparency given the tool's simplicity.

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 compact and information-dense, front-loading the key point ('Text transforms') followed by a concise enumeration of operations and argument mappings. All sentences earn their place; no filler is present.

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 covers all operation modes and parameter relationships, which is substantial for a 6-parameter tool. It lacks explicit return-value details, but the schema and operation names imply the transformed string. Given no output schema and no annotations, the description is reasonably complete for successful 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 description adds meaningful grouping: 'op, text (for slugify/case), or template + data (for template)'. It clarifies how the parameters combine for different modes, going beyond the individual schema descriptions and adding conceptual 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 clearly states it performs 'Text transforms' and enumerates exact operations (slugify, case conversion variants, template filling). It distinguishes from sibling tools by its specific text-processing scope, and the op list leaves no ambiguity about what the 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?

It provides clear context on when to use each mode: 'op='slugify' -> URL slug', case conversion ops, and template filling with placeholders. It doesn't explicitly name alternative sibling tools or exclusion criteria, but the context is unambiguous for a text-transformation utility.

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

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

With no annotations, the description carries the full burden and does well by disclosing the payment requirement ($0.001, x402), the challenge/response flow, and the return fields. It lacks details on error handling or rate limits, but the core behavioral contract is clearly conveyed.

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 dense paragraph, front-loaded with the paid indicator and then the core purpose. It packs essential info without excessive fluff, though a slight restructuring could improve readability. Still, it earns every sentence.

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?

Although there is no output schema, the description lists the return values (converted datetime, UTC offsets, tz abbreviations, DST flags, offset difference), explains the payment flow, and mentions the free teaser. For a paid converter, this is quite complete, though error cases are omitted.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds minimal extra meaning beyond listing args and noting the x_payment behavior, which is already covered by the schema. Baseline 3 is appropriate.

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

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

The description clearly states 'Convert an instant between IANA time zones with historically-correct DST' — a specific verb and resource. It distinguishes timezone conversion from sibling tools like convert, currency, or datemath by focusing on IANA zones and DST handling.

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 clear context: it is a paid tool with a specific payment flow, and it mentions a free HTTP API teaser. However, it does not explicitly state when to use this over sibling tools or list exclusions, though the specialized domain makes misuse unlikely.

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