Blixtworks

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 cost ($0.005), the payment method (USDC on Base), the two payment options (paymentTx or payerAddress), and the output structure (checksum form and account type). This is significantly more transparent than typical tool descriptions.

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: the first sentence states the core functionality, and the second adds payment details. Every sentence earns its place, with no wasted words or repetition of schema 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 simplicity and lack of an output schema, the description provides enough context: it specifies the input format, the return value, and the cost/payment steps. It could mention failure modes (e.g., invalid address) or edge cases, but the essential information for an agent to invoke the tool correctly is present.

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 provides example values for 'address' and 'chain' (0x... and base), and explains the semantics of paymentTx and payerAddress in the context of paying for the service. While the schema covers 50% of parameters, the description fills the gap for the remaining two and adds practical usage context, making all four parameters clear.

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

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

The description clearly states the specific action: 'Validate an EVM address and detect whether it is a contract.' This distinguishes it from sibling validation tools like email_validate or iban_validate, and includes the resource (EVM address) and the exact output (checksum form and account type).

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 (for EVM address validation and contract detection) and even includes usage details like the HTTP POST format and payment requirements. It stops short of explicitly naming alternatives or exclusion criteria, but the purpose is specific enough that a user would understand when to select 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 full burden. It transparently discloses the cost ('Costs $0.005 in USDC on Base'), the payment mechanism ('pass paymentTx or payerAddress to pay'), and the request/response structure ('POST {...} -> result'). It does not mention rate limits or input size constraints, but for a simple stateless encoder, the payment disclosure is a critical behavioral trait that goes beyond basic expectations.

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 with a clear front-loaded purpose. The request example is compact and the cost/payment sentence is essential. No filler or repetition; every sentence earns its place.

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

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

The description covers the main purpose, cost, and payment, but it lacks a detailed return format—saying only '-> result' which is vague. There is no mention of potential errors, size limits, or how to interpret the output. The inclusion of 'urlSafe' in the example while not being a schema property could confuse agents about actual accepted parameters. Given no output schema, the description should provide more clarity on the response 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?

The schema has descriptions for 'paymentTx' and 'payerAddress' but not for 'mode' or 'text.' The description compensates by explaining 'mode' values ('encode'|'decode') and showing a concrete example with 'text.' It also introduces 'urlSafe' in the example, which is not in the schema, adding extra information. However, it doesn't elaborate on the format of 'paymentTx' beyond what the schema says, and the 'urlSafe' parameter is ambiguously presented as part of the request.

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 and resource: 'Base64 encode or decode.' It specifies the exact request format with 'text' and 'mode' values (encode/decode), which distinguishes it from sibling tools like 'hash' or 'case_convert.' 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?

The description implies when to use the tool (for base64 encoding/decoding) but offers no explicit alternatives or exclusions. It does provide usage context for payment: 'pass paymentTx or payerAddress to pay (call how_to_pay for details),' which guides the user on required payment steps. However, there is no guidance on when to use this instead of another tool.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It clearly discloses the $0.02 cost, the payment mechanism (paymentTx or payerAddress), and the need to consult how_to_pay. It also specifies the input format and output nature, which is valuable transparency for a paid operation.

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

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

The description is extremely concise: two sentences. The first sentence states the core purpose and input/output, the second addresses cost and payment. Every sentence carries useful information with no redundancy or filler.

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

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

For a tool with three parameters and no output schema, the description covers the essential context: purpose, input format, output, cost, and payment. It appropriately references the how_to_pay tool for detailed payment instructions. It lacks error-handling details, but for a simple utility this is sufficient.

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 enriches parameter understanding by specifying that paymentTx and payerAddress are alternative payment methods and that image accepts a URL or data URI. While the schema already documents two of three properties, the description adds crucial context about how the params interact (alternative vs. required) and the input format.

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: 'Image captioning' with a specific input format (URL or data URI) and output format (one-sentence natural-language description). It uses a specific verb and resource, making it distinct from sibling image tools like image_resize or image_crop.

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 use case (captioning images) but does not explicitly contrast it with alternative tools or provide when-not-to-use guidance. The mention of payment details suggests the user will need to arrange payment, but no explicit exclusions or alternatives are listed.

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 transparently states the cost ($0.005), the payment mechanism (paymentTx or payerAddress), and the HTTP method (POST). This goes beyond the schema and informs the agent of the tool's side effects and prerequisites. It does not cover error cases, but the core behavioral traits are well disclosed.

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 packs the purpose, input format, cost, and payment instructions without waste. It leads with the core action ('Convert text case') and then layers on necessary details, making it both concise and well-structured. Every clause earns its place.

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

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

For a simple conversion tool with no output schema and no annotations, the description covers the essential aspects: operation, input structure, payment, and expected result ('converted text'). It could explicitly state whether text and to are required, but the example body implies their necessity. Overall, it provides enough 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 coverage is only 50% (descriptions only for paymentTx and payerAddress). The description compensates by explicitly defining the 'to' parameter as an enum of case formats and showing the 'text' parameter in the example body. It also clarifies the two payment parameters' roles, adding meaning beyond the schema's minimal 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 text case.' It enumerates the supported target formats (camel, snake, kebab, pascal, upper, lower, title), which clearly distinguishes it from sibling tools like slugify or other text utilities. This leaves no ambiguity about the tool's function.

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 explains the HTTP method (POST), the expected body format, and the payment requirement, including the two payment options and a pointer to how_to_pay for details. While it doesn't explicitly mention alternatives or when not to use it, it offers sufficient usage guidance for an agent to invoke it correctly.

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

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

With no annotations, the description carries the burden and does well by disclosing the $0.02 USDC cost, the payment mechanism (paymentTx or payerAddress), and the output format. It lacks details on image format constraints or error handling, but the critical cost and payment behaviors are 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 a single dense sentence containing an example, output spec, cost, and payment directions. It is efficient but slightly technical due to inline JSON; every clause 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 4-parameter tool with no annotations and no output schema, the description covers input format, output shape, cost, and payment steps. The reference to how_to_pay for payment details adds a dependency, but overall it gives enough 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 schema has no descriptions for image and labels, and the description compensates by specifying 'image' as '<https url or data URI>' and 'labels' as an optional array of custom labels. It also explains payment parameters, complementing the schema for those fields.

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

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

The description clearly states 'Zero-shot image categorization (CLIP)' with a concrete POST example and output as 'ranked labels with confidence scores.' It distinguishes from siblings like caption or image_palette by specifying it labels images with custom labels.

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 (categorize an image with optional custom labels) but does not explicitly contrast with alternatives or state when not to use it. The mention of how_to_pay is for payment details, not usage scenarios.

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

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

With no annotations, the description carries the full burden. It adds that the tool is 'free' and reports 'currently' unspent credit, but it does not disclose read-only nature, potential errors, or rate limits. This is adequate for a simple tool but lacks 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, concise sentence that immediately communicates the core function. There is no redundancy or irrelevant information, making it highly efficient.

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 1-parameter tool with no output schema, the description offers a basic understanding but omits important context such as how to differentiate from wallet_balance and what the return value looks like (e.g., numeric amount, unit). The existence of sibling tools heightens the need for usage guidance.

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

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

The schema already fully describes the single 'address' parameter as 'Your wallet address'. The description merely repeats 'wallet address' without adding format examples or additional context, so it adds no 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 that it checks the amount of unspent credit for a wallet address on this endpoint, which is a specific resource. It distinguishes this from generic wallet balance tools, but does not explicitly name alternatives, so it falls short of a 5.

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

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

No guidance is provided on when to use this tool versus alternatives like wallet_balance or other credit-related tools. The prefix 'Free:' is a pricing note, not usage context, and no exclusions or prerequisites are mentioned.

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

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

With no annotations, the description carries full responsibility, and it does well. It discloses the cost ($0.005 in USDC), the payment methods (paymentTx or payerAddress), where to find payment instructions (how_to_pay), and the response structure (hex, rgb, hsl, luminance/contrast info).

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 core function, and includes both an example and payment details without any filler. 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?

For a simple conversion tool without an output schema, the description covers the input format, output fields, cost, and payment. It doesn't mention error handling or potential edge cases, but given the tool's simplicity, it is largely 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 description adds meaning beyond the schema: the example 'color': '#2563eb' clarifies the accepted format, and it explains that paymentTx and payerAddress are ways to pay, complementing the schema descriptions. However, it doesn't detail all possible color formats, so it's not a full substitute.

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: 'Convert colours between hex, RGB and HSL.' It also provides an example request and the exact output fields, making it unambiguous and distinct from sibling tools like currency_convert or case_convert.

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 usage is evident from the description, and it gives a clear example of how to call it. It doesn't explicitly exclude any use cases or mention alternatives, but the specificity of color conversion makes it easy for an agent to decide when 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses the $0.01 cost and the payment requirement, which is critical behavioral information beyond what the schema provides. It also shows the expected request format. It could add more on error handling or response format, but the current disclosure is strong.

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 purpose, followed by a concrete example and payment info. The example is useful but it includes an unsupported field, which costs it a point for structure and precision. Overall, it is concise and not padded.

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 tool's primary function, provides an example request, and explains the payment requirement. It lacks explicit information about the response structure, but the phrase 'list upcoming run times' implies the output. Given no output schema exists, 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 descriptions cover only paymentTx and payerAddress; expression and count lack descriptions. The example body helps by showing example values for expression and count. However, the example also includes 'timezone' which is not a property in the schema, and the schema sets additionalProperties=false, making this example invalid as written. This partially undermines the parameter guidance.

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: 'Explain a cron expression and list upcoming run times.' It uses a specific verb ('explain') and resource ('cron expression'), and it distinguishes itself from sibling tools by covering a niche functionality not offered by any sibling.

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, including a concrete POST example and payment instructions. It explicitly tells the user to pay via paymentTx or payerAddress and refer to how_to_pay for details. It does not explicitly mention when not to use it or name alternative tools, but the context is sufficient for a novice.

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

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

The description discloses cost, payment method, and output format, which is useful given no annotations. However, it omits error handling, input size limits, and creates confusion by mentioning 'header' and 'delimiter' in the example though they are absent from the schema. This gap in behavioral disclosure keeps it from scoring higher.

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 core purpose, and packs the example and payment details into the second sentence. Every word earns its place, and the code-style example is compact and readable.

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 conversion tool, the description covers the main purpose, output shape, and payment, but it fails to reconcile the header/delimiter example with the schema's additionalProperties:false. This gap could mislead an agent into sending unsupported parameters, and there is no guidance on required fields or error behavior.

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

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

Schema coverage is 67% (paymentTx and payerAddress have descriptions), so the baseline is 3. The description adds an example showing the csv parameter and the header/delimiter fields, but these last two are not in the schema, muddying the contract. It does not clarify the csv parameter itself, so the added value is limited.

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 converts CSV to JSON, with a specific output format (array of objects or arrays). This verb+resource pair distinguishes it from sibling tools like json_to_csv, making its 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 practical usage context: a concrete POST body example, the effect of the 'header' flag, and cost/payment instructions. It does not explicitly contrast with alternatives, but for a straightforward conversion tool, the guidance is sufficient.

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 disclosure burden. It transparently mentions the $0.02 cost, payment via paymentTx or payerAddress, and the data source. However, it does not explain what happens if payment is missing, and the example's 'date' parameter is not in the schema, creating a potential behavioral mismatch.

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

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

The description is concise, with the purpose stated first, followed by a practical example and payment details. It is compact and well-structured, though the example's unsupported date parameter slightly detracts from its overall precision.

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

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

With no annotations, no output schema, and 5 parameters, the description needs to be more thorough. It covers purpose and payment but omits details like rate limits, behavior if payment is absent, and currency code format. The critical date/schema conflict creates a significant gap, making the description incomplete for reliable tool 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 example clarifies amount, from, and to (e.g., EUR, SEK), but the 'date' parameter in the example is not present in the schema (which has additionalProperties: false). The schema only documents paymentTx and payerAddress, so 60% of parameters lack descriptions. The description introduces a conflicting parameter, undermining clarity.

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

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

The description clearly states the tool converts currency at current or historical reference rates, with a specific data source (ECB via Frankfurter). The included example distinguishes it from generic unit conversion tools like unit_convert.

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 through an example but does not explicitly contrast with alternatives or state when not to use this tool. No exclusions or alternative references are provided, leaving usage context only implicitly defined.

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 so well: it discloses the cost ($0.005 in USDC on Base), the payment methods (paymentTx or payerAddress), and the return values (days, hours, business days, human summary). This exceeds expected transparency for a simple computation 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 two sentences, front-loaded with the core function, then the example, then cost and payment instructions. Every sentence provides necessary information with no redundancy or filler.

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

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

Without an output schema, the description explains the return structure (days, hours, business days, human summary) and covers usage and payment. It lacks edge-case handling details (e.g., reversed dates), but for a straightforward utility it is largely 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 paymentTx and payerAddress (50% coverage), so the description compensates for the undocumented from/to parameters by providing an example with specific date formats. It also clarifies the payment parameter alternatives, adding 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 clear verb+resource ('Difference between two dates') and provides a concrete example with the expected output (days, hours, business days, human summary). This adequately distinguishes it from sibling tools like timestamp or cron_parse.

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 includes a usage example and explains the payment requirement, giving clear context for when to use the tool. However, it does not explicitly mention when not to use it or name alternative tools, stopping short of a full 5.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It clearly states the cost ($0.01 in USDC), the required payment mechanism (paymentTx or payerAddress), references how_to_pay for details, and describes the expected return output. This covers key behavioral traits, though it omits error handling and 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 three sentences long, starting with the core purpose, then the input/output structure, then the payment requirement. Every sentence is dense with necessary information, and there is no redundant or filler content.

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

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

The description covers the essential purpose, input format, output, and payment, but lacks important contextual details: the 'mode' parameter is not present in the schema, requiredness of parameters is unclear, and there is no mention of text length limits or failure modes. Since there is no output schema, the description should be more thorough to compensate.

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 adds significant meaning beyond the sparse schema: it defines 'a' and 'b' as the texts to compare, which the schema does not, and introduces the 'mode' parameter (even though it is missing from the schema). It also clarifies how paymentTx and payerAddress relate to payment. However, the discrepancy between the described 'mode' parameter and its absence from the schema is a concern.

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 clear, specific verb+resource: 'Compare two texts.' It further specifies the output (unified diff and added/removed counts) and lists modes, making the tool's purpose unambiguous. No sibling tool overlaps with this exact functionality, so it effectively distinguishes 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?

The description implies when to use the tool—whenever you need to compare two texts—but it does not explicitly state usage scenarios, exclusions, or alternatives. It focuses more on how to invoke and pay for the tool rather than when to choose it over other tools.

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

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

Discloses cost in USDC on Base, payment method via paymentTx or payerAddress, and output units (km, miles, bearing). Since no annotations are provided, this context is essential and 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?

Two sentences, front-loaded with purpose and example, no redundant text.

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?

Covers purpose, input structure, output format, cost, payment, and points to how_to_pay for details. Sufficient for a simple tool with no 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?

The description adds the structure of 'from' and 'to' as objects with lat/lon, which the schema leaves open. It also clarifies paymentTx and payerAddress usage, complementing the schema's 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 clearly states the tool computes great-circle distance between two coordinates, with an explicit example. It distinguishes from any generic 'distance' tool by specifying the calculation type.

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 use (latitude/longitude pairs) and includes an example. It doesn't explicitly mention alternatives, but no direct sibling overlap exists; payment instructions are included.

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 takes on the full burden. It discloses the cost ($0.01 in USDC on Base) and payment requirements (paymentTx or payerAddress), and points to how_to_pay for details. However, it does not mention error handling, response format details, or what happens if payment is insufficient, so it's not fully transparent.

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

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

The description is concise, front-loaded with 'DNS lookup', and packs the request format, cost, and payment instruction into two sentences. Every element earns its place 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 simple DNS lookup tool with no output schema, the description covers purpose, request format, cost, and payment guidance. It falls short on describing the output structure ('resolved records' is vague) and error behavior, but overall is sufficient for the complexity.

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

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

The description supplies meaning beyond the schema by listing allowed values for 'type' and giving a concrete example for 'domain', both of which lack descriptions in the schema. It also explains the payment parameters, compensating for the 50% schema coverage.

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

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

The description clearly states 'DNS lookup' and provides the exact request format with domain and type parameters, making the tool's purpose unambiguous. It implicitly distinguishes from siblings like ens_resolve, as DNS and ENS are different lookup systems.

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 by stating 'DNS lookup' and showing how to invoke it, but it does not explicitly state when to use this tool versus alternatives like ens_resolve. There is no mention of when not to use it or exclusions, so the guidance is implied rather than explicit.

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

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

With no annotations, the description carries the burden of disclosing behavior. It transparently states the live MX check, the $0.01 cost, and the need to pay via paymentTx or payerAddress, pointing to how_to_pay for details. However, it does not disclose potential failure modes or the exact structure of 'deliverability signals'.

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

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

The description is concise, two sentences, front-loaded with the core purpose, and then provides cost and payment details. The inline JSON example is useful 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?

The tool is a paid API call with no output schema or annotations. While the description covers purpose, cost, and payment, it leaves the return value vague ('deliverability signals') and does not specify the response format or error handling. This is a significant gap for a tool with financial implications.

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 67% of parameters with descriptions. The description adds clarity by showing an example email format ('a@b.com') and explicitly noting that paymentTx and payerAddress are alternative payment methods. This clarifies the relationship between the two payment parameters, which the schema does not specify.

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 an email address, specifying both syntax checking and a live MX record check. It distinguishes itself from sibling tools like address_validate and iban_validate by focusing on email and deliverability signals.

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: when email validation with MX record checking is needed. It also explains the cost and payment process, but does not explicitly contrast with alternatives 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?

With no annotations, the description carries the full burden. It discloses the cost ($0.015), payment methods (paymentTx/payerAddress), input format (URL or data URI), and output (512-dim vector). Missing error behavior but covers key transaction aspects.

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 a concise POST example. Front-loaded with the core purpose and includes only necessary details about cost and payment. Zero wasted words.

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

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

For a 3-param tool with no output schema, the description covers the purpose, input, output, and payment. Lacks image size/format constraints, but overall gives a complete picture for invoking 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?

The description adds meaning beyond the schema: clarifies that 'image' accepts an https URL or data URI, and explains the payment parameters. Schema coverage is 67%, so this extra detail compensates for the undocumented image parameter.

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 performs CLIP image embedding and returns a 512-dim vector for similarity search. This specific verb+resource framing distinguishes it from sibling image tools like caption or image_resize.

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 the use case 'for similarity search' and directs users to how_to_pay for payment details. Does not explicitly exclude alternatives, but the context is clear enough.

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

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

No annotations are provided, so the description must carry the full burden. It discloses cost and payment methods, and clarifies that both forward and reverse resolution are supported. However, it omits the response shape or any error conditions, leaving parts of expected behavior 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 two sentences with no wasted words. It front-loads the core purpose and includes necessary payment information, making it efficient and appropriately sized.

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 a paid resolver with no output schema, so the description should clarify return values and payment flow. It references how_to_pay for details but omits output format and contains a schema/description mismatch around the 'address' parameter, leaving the agent with ambiguity in real usage.

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

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

The input schema only includes 'name', 'paymentTx', and 'payerAddress', but the description suggests an 'address' parameter in examples, which is not in the schema and would be rejected due to additionalProperties: false. While it adds meaning to 'name', it misleads about accepted inputs and does not fully compensate for the schema's limited 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 clearly states the tool resolves ENS names to addresses and vice versa, with explicit examples. It distinguishes itself from sibling tools by focusing on ENS resolution, a unique purpose among the listed tools.

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

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

The description gives clear context for when to use the tool (resolving ENS names/addresses) and directs users to how_to_pay for payment details. However, it does not explicitly mention alternatives or when not to use, but the unique purpose makes exclusions unnecessary.

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

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

With no annotations, the description carries the full burden. It discloses the cost ($0.01), payment method, and the need to call how_to_pay for details. However, it does not explain failure modes, what happens without payment, or output format details, which leaves gaps for full 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 concise and front-loaded: two sentences. The first sentence states the purpose and input/output format, the second provides cost and payment instructions. No wasted words.

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

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

For a straightforward extraction tool, the description covers purpose, input, output types, cost, and payment. However, it assumes the user knows 'image' is required (schema shows 0 required) and does not describe error handling or response structure. Still, it is quite complete for the tool's simplicity.

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 two of three parameters with descriptions, but the 'image' parameter lacks description. The description compensates by specifying that 'image' is a URL or data URI. It also clarifies the payment parameters (paymentTx and payerAddress) with context about cost and credit.

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: 'EXIF metadata extraction' and specifies the input format (POST with image URL or data URI) and output categories (camera, timestamps, GPS). This distinguishes it from sibling image tools like image_info or ocr.

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: when EXIF metadata from an image is needed. It also covers the cost and payment requirement, which is essential for using the service. It does not name alternatives explicitly, so it falls 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.

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

With no annotations, the description carries the full burden. It transparently discloses that the tool costs $0.01 in USDC on Base and specifies payment methods (paymentTx or payerAddress). It also mentions the output structure (gwei, block number, transfer cost). It doesn't cover rate limits or error cases, but the key behavioral trait (paid) is clearly stated.

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 primary purpose, and includes payment and output details without unnecessary fluff. Every word earns its place.

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

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

Given there is no output schema, the description adequately covers input, output, and payment. It explains the cost and points to how_to_pay for further details. A minor gap is that despite 0 required parameters in the schema, the POST example implies chain is necessary, which could confuse.

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 67%, with chain lacking a description. The description compensates by explicitly showing allowed values ('base'|'ethereum') in the POST example. paymentTx and payerAddress are also clarified as payment methods, adding value beyond the schema's brief 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 clearly states the tool's purpose: 'Current gas price and what a transfer costs.' It specifies the input format (chain) and output (gwei, block number, estimated transfer cost), making it distinct from any sibling tools.

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

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

The description provides clear context for when to use the tool (to get gas price and transfer cost) and importantly details the payment prerequisite and how to pay, referencing how_to_pay. It doesn't explicitly name alternatives but none are obvious siblings for this 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?

With no annotations, the description carries the full burden of behavioral disclosure. It transparently mentions the cost, the payment methods (paymentTx or payerAddress), and default algorithms, which is valuable context. However, it does not describe the exact response structure or error behavior, which would be helpful.

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 core purpose ('Cryptographic hashes'), and includes all necessary details without extraneous text. Every part 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?

Despite lacking an output schema, the description explains input, output (hex digests), defaults, and payment. It is sufficiently complete for a simple computation tool, though it could specify how outputs are keyed by algorithm.

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 50%, so the description compensates by explaining text and algorithms with an example and default behavior. It also references paymentTx and payerAddress, though their schema descriptions already exist. Overall, it adds meaningful context 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 identifies the tool as computing cryptographic hashes and specifies the request format (POST with text and algorithms) and output (hex digests). This distinguishes it from siblings like hmac and base64, which serve different purposes.

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

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

The description implies usage by showing an example POST and defaults, but does not explicitly state when to use this tool over alternatives like hmac. It does provide contextual information about payment requirements, which helps in deciding whether to use it, but lacks exclusions or comparisons.

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

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

With no annotations, the description carries the full transparency burden. It discloses that the operation is a POST request, returns both hex and base64 signatures, costs $0.005 in USDC on Base, and requires payment via paymentTx or payerAddress (pointing to how_to_pay). This adds significant behavioral context beyond merely stating 'HMAC signature', though it omits error handling or rate limit details.

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: the first delivers the core functionality and request format, the second covers cost and payment. No filler words, no repetition of schema fields, and the most important information is front-loaded. Excellent conciseness.

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

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

The tool is simple with 5 optional parameters and no output schema. The description covers the request format, the output (hex/base64 signature), cost, and payment mechanism. It references how_to_pay for further detail, which is useful. It does not explicitly state the exact response JSON structure, but 'hex and base64 signature' sufficiently conveys the return format for an agent.

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

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

Schema description coverage is only 40% (paymentTx and payerAddress are described; text, key, algorithm are not). The description partially compensates by showing an example payload with text/key/algorithm, making their roles somewhat clear (message, secret key, hash algorithm). However, it does not explicitly define each parameter, enumerate valid algorithms, or clarify optionality beyond the schema, leaving some 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?

The description clearly states 'HMAC signature' and provides a concrete request/response example (POST with text, key, algorithm -> hex and base64 signature). This definitively identifies the tool's function and distinguishes it from siblings like base64 or hash, which are non-keyed or purely encoding operations.

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 when to use the tool (whenever an HMAC signature is needed) through its definition and example, but it does not explicitly contrast with alternatives such as 'hash' for non-keyed hashing or 'base64' for encoding. No explicit when-not-to-use guidance is provided, so it relies on the user inferring the appropriate context.

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

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

With no annotations, the description carries the full burden of disclosure. It mentions the tool is free and lists the information covered, but it does not explain how the 'tool' parameter affects the response or what the output format will be. This is a notable gap for a tool with an optional parameter.

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, front-loading the key fact that it is free and what it covers. The 'Free:' prefix is slightly cryptic but the overall structure is efficient and waste-free.

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 optional parameter and no output schema, the description should explain the parameter's role and the expected return value. It also fails to differentiate itself from payment-related sibling tools. The description covers the core purpose but omits these important contextual details, leaving it incomplete.

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

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

The schema provides 100% coverage for the 'tool' parameter ('Get the exact price for one tool'), so the baseline is 3. The description adds no additional parameter semantics and does not connect the parameter to the payment steps or credit information.

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 indicates the tool provides payment steps, the receiving address, and explains how credit works, distinguishing it from siblings like redeem_payment and check_credit. However, it lacks a direct verb, making it a fragment rather than a full statement of action.

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 is implied: someone who needs to know how to pay or how credit works would use this tool. However, it does not explicitly state when to use this tool versus alternatives such as redeem_payment or check_credit, nor does it provide exclusions.

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

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

The description discloses cost ($0.01 USDC), payment options, the HTTP method (POST), and expected output fields. However, it includes 'method': 'HEAD' in the example, which is not present in the input schema, potentially confusing an agent. With no annotations provided, the description carries the full burden, but this inconsistency and lack of error-handling details prevent a higher score.

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

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

The description is two sentences and front-loads the core purpose. It packs in output details, cost, payment, and a reference to how_to_pay without excessive verbosity. However, the POST example with 'method' is arguably extraneous and could mislead, so it earns a 4 rather than 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?

Despite having no output schema or annotations, the description covers the input (URL), output (status, headers, timing, redirect chain), cost, and payment flow. This is sufficient for a relatively simple tool, but the mismatch between the example's 'method' field and the actual schema leaves a gap, preventing a perfect score.

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 clarifies the roles of paymentTx and payerAddress ('pass paymentTx or payerAddress to pay') and gives a URL example, adding meaning beyond the schema where url lacks a description. Since schema coverage is already 67%, this extra context pushes it above the baseline of 3, though the method field confusion slightly detracts.

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 ('Inspect') and resource ('HTTP response headers for a URL'). It also lists the outputs (status, headers, timing, redirect chain), which distinguishes it from sibling tools like dns or ssl_check. This is unambiguous and immediately understandable.

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 is implied from the purpose statement—'Inspect HTTP response headers for a URL'—but there is no explicit guidance on when to use this tool versus alternatives, nor any when-not-to-use conditions. The mention of calling how_to_pay is payment guidance, not tool selection guidance, so it doesn't elevate the score beyond implied usage.

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

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

With no annotations provided, the description carries the full burden. It adds critical behavioral context: the tool costs $0.005 in USDC on Base, requires payment via paymentTx or payerAddress, and directs to how_to_pay for details. It also includes a concrete example of the request body. However, it does not disclose the response format or error behavior, which is a minor gap.

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

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

The description is concise, with two sentences that cover purpose, an example, cost, and payment instructions. No word is wasted, and the most important information appears early.

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 validation tool, the description covers essential aspects: what it does, how to call it (example), cost, and how to pay. It lacks an explicit statement about the return value, but this is not critical for a validation tool's core use, and the lack of an output schema reduces the need for detailed return documentation.

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 67% description coverage; the 'iban' parameter lacks a description. The description compensates by providing an example value and clarifies the payment-related parameters. This adds meaning beyond the schema, though it could better specify IBAN formatting rules (e.g., spaces, case).

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 an IBAN, specifying the validation criteria (checksum and country length). This distinguishes it from sibling validation tools like luhn_validate and address_validate by naming the specific resource and validation type.

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 by stating the validation purpose and provides an example, but it does not explicitly mention alternatives or when not to use this tool. The payment instructions (pass paymentTx or payerAddress) are operational guidance, not tool-selection 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 carries the full burden of behavioral disclosure. It discloses the output format (data URI), the cost ($0.02 USDC on Base), and the payment options (paymentTx or payerAddress). This adds significant value beyond what annotations would provide, though it does not discuss failure modes or boundary behavior.

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

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

The description is a single, concise sentence with an embedded code block example and a clear payment instruction. It is front-loaded with the purpose and includes only essential details, making every word count.

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 (7 parameters, no output schema, no annotations), the description covers the core functionality, provides an example, and explains payment. It also points to how_to_pay for further details. Missing are edge-case behaviors like error handling or coordinate bounds, but the main use case is adequately addressed.

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 only 29% (paymentTx and payerAddress have descriptions). The description compensates partially by providing a full JSON example that clarifies the image, x, y, width, and height parameters. However, it does not explain the coordinate system, units, or constraints for these parameters, leaving some 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?

The description clearly states the tool's function with a specific verb and resource: 'Crop an image.' It also includes a concrete example and distinguishes itself from sibling tools like image_resize and image_transform by explicitly naming the crop operation.

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 through the verb 'crop' and provides a request example, but it does not explicitly state when to choose this tool over alternatives like image_resize or image_transform. There is no mention of when not to use it or exclusions, so usage guidance remains implied 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. It discloses pricing ($0.01 USDC on Base), payment methods (paymentTx or payerAddress), and the returned fields. However, it omits error behavior, input format constraints beyond the URL example, and any side effects, making it adequate but not exhaustive.

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 contain all essential information: purpose, HTTP method, output fields, cost, and payment instructions. Every sentence earns its place, with no redundant or filler content.

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

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

Given no output schema and no annotations, the description lists the return fields, which is crucial. It also covers the payment flow adequately. Minor gaps like error handling or supported formats are present but not critical for such a simple 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 67%, with the image parameter lacking a description. The description compensates by showing an example POST body with a URL, clarifying that image expects a URL. It also explains that paymentTx and payerAddress are alternative payment methods, enriching the schema descriptions already present.

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

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

The description clearly states the tool provides 'image dimensions and properties' and lists specific output fields (width, height, aspect ratio, format, file size, transparency). The phrase 'without any ML' distinguishes it from ML-based siblings like caption or image_palette, 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?

It implies usage for basic image information extraction via 'without any ML', which sets it apart from ML-heavy alternatives. It does not explicitly name alternatives or state when not to use it, but the context is clear. The pointer to how_to_pay for payment details also guides users on a prerequisite step.

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. It discloses the cost, the necessity of payment (via paymentTx or payerAddress), and the output format. However, it doesn't mention error handling or what happens if no payment is provided, leaving some behavioral gaps.

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

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

Three compact sentences deliver purpose, example, output, and pricing/payment in a front-loaded manner with zero filler.

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

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

Despite lacking an output schema, the description explains the return value (hex colours with share percentages), the request format, and the payment requirement. For a simple 4-param tool, this 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?

Schema covers only 50% of parameters (paymentTx and payerAddress have descriptions; image and colors do not). The description compensates by giving a concrete example: 'image': 'https://...', 'colors': 5, and clarifies that colors is the number of palette entries. It also explains the purpose of paymentTx/payerAddress.

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 and resource: 'Extract the dominant colour palette from an image.' It also provides an example POST and output format, clearly distinguishing it from sibling image tools like image_crop or image_info.

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 clearly indicates when to use it (to extract a palette) and references how_to_pay for payment details. It doesn't explicitly contrast with alternatives, but the context is sufficient for a paid utility tool.

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

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

No annotations are provided, so the description carries full burden. It discloses the cost and payment mechanism, and the return type, but creates a contradiction by showing 'text' in the example payload while the schema disallows it. Gradient functionality is also left 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 concise, fitting in two sentences with an example and cost. However, the example includes an undocumented 'text' field, which introduces confusion and reduces structural 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?

As a paid API with no output schema, the description should clarify gradient configuration, text support, and payment verification. It only provides a basic example and cost, leaving significant gaps and the schema mismatch unresolved.

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 low (40%). The example gives meaning to width, height, and color, but no units, ranges, or gradient specification. The 'text' field is not in the schema, and paymentTx/payerAddress are already documented in the schema, adding no new 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 clearly states the tool 'Generate a solid or gradient placeholder image' and specifies the HTTP method (POST) and response format (PNG data URI). This distinguishes it from sibling image manipulation tools like image_crop or image_transform.

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 explicit usage context: POST with dimensions and color, payment via paymentTx or payerAddress, and directs to how_to_pay for details. It does not explicitly contrast with sibling tools, but the purpose is unique enough that no exclusion is needed.

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?

Despite lacking annotations, the description discloses important behavioral traits: the cost ($0.02), the payment requirements (paymentTx or payerAddress), and the return format (data URI). It also directs users to how_to_pay for details. However, it does not discuss side effects, error handling, or what happens if payment is omitted.

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

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

The description is concise and front-loaded with the main action, followed by a concrete example and payment info. Every sentence contributes meaning, and the whole text fits in two sentences without fluff.

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 adequately covers the return value (data URI) and payment mechanism, but lacks important details such as expected units for width, supported image formats, and behavior on invalid inputs. The mismatch between the example's extra parameters and the schema leaves gaps that could lead to invocation errors.

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 only 50% (paymentTx and payerAddress have descriptions, image and width do not). The description partially compensates by providing example values for image and width, and revealing additional fields (height, format, quality) that are not in the schema. However, this creates confusion because those extra fields are not actually listed as allowed parameters, making the parameter semantics inconsistent.

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 specific action: 'Resize or convert an image.' It also gives a concrete example of the input and output, and the scope is distinct from sibling tools like image_crop or image_palette, making 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 implies usage for resizing/converting images and illustrates the expected request format, but it does not explicitly mention when to use this tool over alternatives such as image_transform or image_crop. No exclusions or alternative tool references are provided, so guidance is only implied.

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

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

There are no annotations, so the description carries the full burden. It discloses the $0.02 cost and payment via paymentTx/payerAddress, which is important. However, it fails to explain required vs optional parameters, the return format (only 'transformed image'), or error conditions. Moreover, the schema lists no required parameters while the description implies 'image' is required, and the example includes non-schema fields, making the behavior unclear.

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 fairly concise, with an initial clear purpose and a compact example. The payment note is necessary and kept brief. However, the JSON example could be streamlined, and the inclusion of unsupported parameters makes it less clean.

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

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

The tool has no output schema and no annotations, so the description should cover response format, error handling, and parameter constraints. It only says 'transformed image' and gives a payment pointer. Given the complexity of a paid image transformation tool, this is insufficient. The mismatch between the example and the schema further reduces completeness.

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

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

Schema coverage is 50%, so the description must compensate for the undocumented 'image' and 'filter' parameters. It does provide enumerated filter values (greyscale, sepia, invert, blur) and an example, but it leaves 'image' unspecified (only '...') and introduces 'rotate' and 'flip' which are not in the schema. This adds context but also confusion.

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

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

The description clearly states the tool rotates, flips, or filters an image, using a specific verb and resource. It distinguishes from sibling image tools like image_crop and image_resize. However, the example in the description includes 'rotate' and 'flip' parameters that are not present in the input schema, creating potential ambiguity.

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

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

The description implies the tool should be used for image transformations (rotate, flip, filter), but it provides no explicit guidance on when to choose this tool over alternatives like image_crop or image_resize. Payment instructions are included, but no usage exclusions or alternative naming.

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 disclosure. It transparently states the cost ($0.01 USDC), the payment mechanism (paymentTx or payerAddress), and expected outputs (A/AAAA and PTR names). It does not mention error behavior or whether host is required, but the core behavioral traits are covered well for a simple lookup 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, information-dense sentence that leads with the core function, then provides a concrete example, and finally states the cost and payment options. No words are wasted; every clause adds essential 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?

For a tool with 3 parameters, no output schema, and no annotations, the description covers the main purpose, example usage, cost, and payment method. It falls short of fully complete by not stating that host is effectively required (schema says 0 required) and by omitting any error or edge-case behavior. However, it is adequate for a straightforward API.

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 describes paymentTx and payerAddress but leaves host without a description. The description compensates by showing host in an example and indicating it is the hostname to resolve. It also clarifies that either paymentTx or payerAddress can be used to pay, adding meaning beyond the raw schema. This effectively fills the missing schema coverage for host.

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 with a specific verb (Resolve) and resource (hostname to IPs), and mentions reverse-resolution, which is a distinct capability. The example POST payload and output (A/AAAA records and PTR names) further clarify its purpose, differentiating it from sibling tools like ens_resolve or dns.

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 through the POST example and payment instructions, but it does not explicitly say when to use this tool vs alternatives. It only references how_to_pay for payment details, not for tool selection. This leaves some ambiguity for an AI agent choosing between ip_lookup and similar tools like dns or ens_resolve.

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 it discloses cost ($0.005), payment method (USDC on Base via paymentTx or payerAddress), and output behavior (formatted output or validation error with position). However, it lacks details on default mode behavior, parameter requirements, and failure consequences for missing payment, so it is not fully transparent.

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

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

The description is a single dense sentence that front-loads the purpose and includes a compact example plus payment info. It is not overly verbose, but the mixing of example, cost, and payment instructions in one sentence is slightly cluttered, still overall efficient.

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

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

Given no annotations and no output schema, the description provides a reasonable overview of purpose, an example, cost, and error output. However, it omits key details such as default mode when not specified, whether payment is mandatory and what happens if omitted, and the exact structure of the 'json' parameter. This leaves the tool underspecified for a complete agent 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 description adds meaning by showing the 'mode' values ('pretty'|'minify'|'validate') and an example payload, including an 'indent' parameter that is not present in the schema, which is confusing. The schema already describes paymentTx and payerAddress, leaving json and mode partially explained. The description helps but does not fully compensate for the schema gaps.

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: 'Format, minify or validate JSON.' It uses specific verbs and identifies the resource, and the example POST body reinforces the three distinct modes. This distinguishes it from sibling tools like json_query (querying) and json_to_csv (conversion).

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 through the example and mode options, but it does not explicitly state when to use this tool versus alternatives like json_query or json_to_csv. There is no mention of excluded use cases or comparisons to other JSON tools. The reference to how_to_pay is about payment, not usage alternatives.

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

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

With no annotations, the description carries the full burden. It discloses the cost ($0.01 USDC), payment methods (paymentTx or payerAddress), and array mapping behavior ([*]). It also shows the HTTP POST request structure. It does not describe errors or return format, but the core behavioral traits are 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: the first sentence states the purpose and example, the second covers cost and payment. Every clause earns its place, 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?

The tool has no output schema, but the description conveys the return concept ('the value at that path'). It also covers cost, payment, and array mapping. It omits error behavior and precise return formatting, but for a simple query tool, this is sufficient context.

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

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

Schema coverage is only 50% (paymentTx and payerAddress have descriptions, but json and path do not). The description compensates by providing an explicit example that explains both json and path parameters, including syntax and array mapping. Payment parameters are already described in the schema, so the description adds value without redundancy.

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: 'Query JSON with a dot/bracket path.' It includes a concrete example ('users[0].name') and explicitly distinguishes this from sibling tools like json_format or json_to_csv by focusing on extraction rather than transformation.

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 (when you need to extract a value from JSON) and gives a usage example. However, it does not explicitly mention alternatives or exclusion criteria (e.g., 'use json_format for pretty-printing instead'), so it lacks explicit 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 carries the full burden of behavioral disclosure. It discloses the cost ($0.01 USDC on Base), the payment methods (paymentTx or payerAddress), and indicates a POST request with a specific payload. However, it also introduces a 'delimiter' parameter in the example that is not present in the input schema, creating inconsistency. It does not mention error handling or edge cases, so transparency is incomplete.

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

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

The description is composed of two concise sentences that front-load the core purpose and then include crucial payment instructions. Every sentence contributes necessary information without redundancy or fluff.

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 lacks annotations and an output schema, so the description must compensate. It covers the main conversion functionality and payment, but omits details about output formatting, error behavior, and the inconsistent delimiter parameter. For a simple utility, it is adequate 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 schema describes paymentTx and payerAddress (67% coverage), and the description adds some clarity for the 'json' parameter by indicating it should be a JSON array of objects. However, the description also mentions a 'delimiter' parameter not defined in the schema, which is misleading. Payment params are already documented in the schema, so the description adds marginal value beyond it.

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

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

The description clearly states the tool's purpose: converting a JSON array of objects to CSV. It uses a specific verb ('convert') and identifies the resource (JSON to CSV). This distinguishes it from sibling tools like csv_to_json, which performs the reverse conversion.

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 by specifying the exact input format (JSON array of objects) and the output (CSV text). However, it does not explicitly state when not to use this tool or mention alternatives such as csv_to_json, so it lacks explicit exclusions. It implies usage through the input/output 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 provided, the description carries the full transparency burden. It discloses key behavioral characteristics: the JWT signature is not verified, it costs $0.01 in USDC on Base, and payment can be made via paymentTx or payerAddress. It also outlines the return components (header, payload, expiry status), going beyond a simple decode statement.

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

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

The description is a single efficient sentence that front-loads the core purpose ('Decode a JWT without verifying it'), then adds the usage example, security caveat, and payment instruction with no redundancy or wasted words.

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

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

Given no output schema and no annotations, the description offers a solid mental model: it explains what is returned (header, payload, expiry status), how to pay, and points to how_to_pay for details. It could be more explicit about the exact response format or error handling, but it is adequate for a simple decode 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 paymentTx and payerAddress with descriptions, but the token parameter lacks a schema description. The tool description compensates by showing token usage ('{"token": "eyJ..."}') and explaining payment semantics. This adds meaningful context beyond the schema for all three parameters.

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

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

The description opens with 'Decode a JWT without verifying it,' specifying the exact action and resource. It clearly distinguishes this from any JWT verification tool by explicitly stating verification is not performed.

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 for when to use this tool (to decode a JWT) and includes a caveat that the signature is not verified, implying it should not be used when verification is required. However, it does not explicitly name an alternative tool for verification, so it lacks an explicit exclusion.

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 the cost ($0.01 in USDC), the payment methods (paymentTx or payerAddress), and the response format (ISO 639-3 code and name). It stops short of explaining error handling or rate limits, but the core behavior is 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 a compact statement that leads with the purpose, then the usage and cost. Every clause provides necessary 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?

For a tool with no output schema, it explains the return value (ISO 639-3 code and name) and the payment prerequisites thoroughly. Minor gaps like maximum text length or error codes are not addressed, but the core usage is 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 already describes paymentTx and payerAddress (67% coverage), and the description compensates for the undocumented 'text' parameter by showing the JSON structure. It also clarifies the distinction between paying with a transaction hash versus using existing credit, adding 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 tool's function: 'Detect the language of a text.' It also specifies the output (ISO 639-3 code and name), making it specific and distinct from sibling tools, none of which perform language detection.

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

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

It provides a concrete usage example ('POST {"text": "..."}') and informs the user of the payment requirement, directing them to how_to_pay for details. This gives clear context on how to invoke the tool, though it does not explicitly discuss alternatives or when not to use it, which is acceptable given no sibling performs language detection.

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 output contents (price, inputs, description) and the free nature, but does not explicitly confirm it is read-only or mention any limitations.

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

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

The description is two short, front-loaded clauses: 'Free: every Blixtworks tool with price, inputs and description (63 tools).' and 'Optionally filter by group.' Every word earns its place with no 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 list tool with one optional parameter and no output schema, the description fully conveys the tool's purpose, what it returns, and how to filter. Nothing critical is missing.

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 lists the 'group' parameter with allowed values (e.g., 'vision', 'media'). The description adds that it is an optional filter, providing meaning beyond the schema's bare enumeration.

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 lists every Blixtworks tool with price, inputs, and description, identifying it as a directory/resource listing. This differentiates it from the many specific sibling tools like 'base64' or 'cron_parse'.

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 this is the catalog for discovering tools and mentions an optional group filter, but does not explicitly state when to use this versus individual tools or exclude scenarios.

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?

Discloses cost and payment methods, and implies output as lorem ipsum text. However, it doesn't address that 'wordsPerParagraph' is not in the schema, creating a contradiction that undermines transparency.

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

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

Two concise sentences, front-loaded with purpose, including cost and a request example. Every word serves a purpose.

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

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

Covers the core usage and payment, but the inconsistency with the schema and lack of parameter constraints make it incomplete for a tool with no output schema or annotations.

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 example includes 'wordsPerParagraph,' which is not allowed by the schema (additionalProperties false), and 'paragraphs' lacks explanation of optionality or range. Payment parameters are already described in the schema, so the description adds little 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 'Generate placeholder text,' which is a specific verb and resource. The example request further distinguishes this from sibling tools like image_placeholder.

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 context on payment (pass paymentTx or payerAddress) and directs to how_to_pay for details. However, it doesn't explicitly state when not to use this tool or mention alternatives.

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

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

With no annotations, the description carries the full burden. It discloses the monetary cost, the payment mechanism (paymentTx or payerAddress), and the output type. It does not mention error handling, rate limits, or side effects beyond payment, but it does provide meaningful context beyond the tool's name.

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?

Three compact sentences: purpose, example request with return value, and cost/payment instructions. Every sentence contributes unique information, is front-loaded, and there is no fluff.

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 aspects: purpose, example, cost, payment, and output. It references how_to_pay for additional payment details. However, it does not provide the exact response structure or behavior on invalid input, which would be useful given there is no 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?

The schema covers 2 of 3 parameters; the description compensates for the undocumented 'number' parameter by providing an example and clarifying it is the identifier to validate. It also clarifies that paymentTx and payerAddress are alternative payment methods, adding useful semantic context beyond the schema.

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

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

The description clearly states the tool validates identifiers using the Luhn checksum, naming specific use cases (credit cards, IMEI, Swedish personnummer) and the output (validity and detected card scheme). This specific verb+resource+scope distinguishes it from sibling validation tools like email_validate or iban_validate.

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 implies when to use it (for Luhn-checksummed identifiers) and gives explicit payment instructions, including referring to how_to_pay for details. However, it does not explicitly contrast with alternative validation tools or state exclusions, so it falls slightly 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.

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 transparently reveals the cost, payment options, and shows a request/response example. However, it does not mention error handling, rate limits, or what happens if no payment is provided, which would be valuable for full transparency.

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

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

The description is a single, front-loaded sentence that states the core action, provides an example, and lists payment requirements. Every clause adds value with no redundancy or filler.

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

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

For a simple conversion tool, the description covers the essential points: purpose, input format, output type, cost, and payment method. It lacks details on edge cases or failure modes, but given the low complexity and the absence of an output schema, it 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 covers paymentTx and payerAddress with descriptions, but the 'markdown' parameter lacks a schema description. The tool description compensates by illustrating usage with '# Title' and stating the conversion. It also adds context for payment parameters by explaining their role in paying for the conversion.

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 'Render Markdown to HTML', a specific verb+resource that clearly states the tool's function. The POST example with input/output further distinguishes it from siblings like 'md' and makes the 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 clearly indicates the payment context ('Costs $0.01... pass paymentTx or payerAddress') and directs the user to 'call how_to_pay for details' for payment instructions. It does not explicitly state when to avoid this tool versus alternatives, but for a conversion tool with a unique purpose, this is adequate context.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It honestly reveals the cost ($0.02 USDC on Base), the payment mechanism (paymentTx or payerAddress), the need to call how_to_pay for details, and the output format. It does not overpromise or contradict any structured data.

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

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

The description is concise yet dense, presenting the purpose, request examples, parameters, cost, payment process, and output in a few sentences. It is front-loaded with the core purpose and uses clear structure with examples and separators, ensuring every sentence earns its place.

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

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

Given no output schema, the description adequately explains return values (clean markdown with title/byline), cost, payment options, and mode behavior. It also references how_to_pay for additional details. The only notable gap is the mismatch between the described 'html' input and the schema, which could confuse an agent, but the overall coverage is strong.

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 50%, so the description must compensate. It adds meaningful detail for url (https format) and mode (article|full, default article). However, it introduces an 'html' parameter that is not present in the schema (which has additionalProperties:false). This is misleading and could lead to invalid invocations, outweighing the helpful parameter clarifications.

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 'HTML to Markdown', a specific verb and resource pair, and further details input formats and output ('clean LLM-ready markdown with title/byline'). This clearly distinguishes it from the sibling tool markdown_to_html, which performs the reverse conversion.

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: for converting HTML to Markdown. It does not explicitly name alternatives or exclusions, but the directionality is unambiguous given the sibling tool list, making the intended use obvious.

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 disclosure and does well: it states the cost ($0.02 in USDC on Base), the two payment options (paymentTx or payerAddress), and that how_to_pay should be consulted for details. It also implies a POST request. This is significant behavioral context beyond the raw operation, though it does not cover failure modes or rate limits.

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: two sentences that lead with the purpose, include a concrete request example, and finish with payment essentials. Every phrase contributes, no filler or repetition. The front-loading of 'Extract page metadata' immediately anchors the reader.

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

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

Despite lacking an output schema, the description enumerates what metadata will be extracted, which serves as return-value guidance. It also covers the critical operational context (POST format, cost, payment methods). It does not explain error conditions or response format, but for a simple extraction tool with no output schema, this 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?

Schema description coverage is 67% (paymentTx and payerAddress have descriptions, url does not). The description adds minimal value for url beyond an example in the POST body, and it repeats the payment parameter semantics already in the schema. It does not explain the relationship between paymentTx and payerAddress or any constraints. With partial schema coverage, this is adequate but not compensatory.

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 ('Extract') and resource ('page metadata'), enumerating the exact metadata fields (title, description, Open Graph, Twitter card, canonical, favicon, language). This distinguishes it from siblings like http_headers or dns, which handle different page-related data.

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 clear context for when to use the tool (when you need page metadata) and even provides an example invocation with POST. It does not explicitly name alternatives or exclusion conditions, but the scope is unambiguous. The pointer to how_to_pay also guides prerequisite steps.

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. It discloses the cost ($0.005 USDC), payment methods (paymentTx or payerAddress), and supported base range (2-36). This is significant beyond the schema, though it does not mention error cases or prerequisites for payment.

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 purpose, and includes a compact example and payment information. Every sentence adds necessary value 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 simple tool with no output schema, the description covers purpose, example, base range, cost, and payment. It references how_to_pay for further details. Slight ambiguity about payment being required (schema has no required params) prevents a perfect score.

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 only 40% (paymentTx and payerAddress have descriptions). The description compensates with a full example showing value as a string and from/to as numbers, plus the base range. It also clarifies that paymentTx and payerAddress are alternative payment methods, adding meaning beyond the schema.

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

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

The description clearly states the tool's function with a specific verb ('Convert'), a specific resource ('a number between bases'), and an example payload. This distinguishes it from sibling converter tools like base64 or currency_convert.

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 a concrete usage example (POST payload) and payment context, which implies when to use it. However, it does not explicitly mention alternatives or when not to use it, so it falls 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.

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

Despite no annotations, the description discloses key behaviors: it requires an HTTP POST with an image URL/data URI, returns extracted text with a confidence score, and costs $0.03 in USDC on Base. It also notes language limitation (English) and payment flow. It omits edge-case behavior like error handling, but covers the core behavioral traits.

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

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

Three compact sentences, each providing essential information: purpose, usage example, and cost/payment. No redundant or filler language.

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

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

The description is reasonably complete for a simple paid OCR tool: it covers input, output, cost, payment, and language scope. It does not cover error handling or image constraints, but these are minor given the tool's simplicity and absence 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?

The schema has no description for 'image', but the tool description fills that gap by specifying 'https url or data URI'. It also clarifies the role of paymentTx and payerAddress (pay vs. spend credit), which aligns with their schema descriptions. This adds meaning beyond the schema for the primary parameter.

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 performs OCR (English), with a POST request example and output summary. While it doesn't explicitly differentiate from sibling image tools like caption, the OCR intent is unambiguous and distinct.

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

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

It implies usage for extracting text from English images and mentions payment necessity, but does not explicitly state when to use vs alternatives or exclusions (e.g., non-English or low-quality images).

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

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

With no annotations, the description carries the full burden of disclosing behavior. It clearly states the cost ('Costs $0.03 in USDC on Base'), the payment requirement ('pass paymentTx or payerAddress to pay'), the exact input format (URL or base64 URI), and the output structure. It also references 'how_to_pay' for details, adding transparency. However, it does not disclose limitations like file size limits, URL accessibility, or how errors are handled.

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

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

The description is three sentences, each adding essential information: purpose/input/output, cost, and payment method. It is front-loaded with the core functionality and has no filler or redundant content. The reference to 'how_to_pay' is efficient and appropriate.

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 essential context: input format, output (plain text, page count, metadata), cost, and payment process. Since there is no output schema, this explanation is necessary and sufficient for basic use. However, it could be more complete by mentioning prerequisites like whether the URL must be publicly accessible or if there are content limitations (e.g., scanned PDFs). These gaps prevent a perfect score.

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 significantly enriches the schema. For the 'pdf' parameter, which lacks a schema description, it specifies the format: '<https url or data:application/pdf base64 URI>'. It also clarifies the payment parameters by explaining that 'paymentTx' or 'payerAddress' are payment methods, reinforcing the schema descriptions. This is especially valuable given the incomplete schema coverage.

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

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

The description clearly states the tool's function: 'PDF text extraction' with a specific output of 'plain text, page count and metadata.' This distinguishes it from siblings like 'ocr' (image text extraction) and 'metadata' (generic metadata extraction). The verb 'extract' plus the resource 'PDF' is 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 does not provide guidance on when to use this tool versus alternatives. It does not mention that this only works for text-based PDFs and that scanned PDFs might require 'ocr', nor does it clarify differences from the 'metadata' tool. The only usage hint is the input format and payment instructions, but no explicit 'use when' or 'use instead' guidance.

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

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

With no annotations, the description must disclose behavior itself. It does mention the payment requirement, cost, and that it returns 'result with explanation', which is valuable. However, it does not describe failure modes (e.g., missing payment), idempotency, or whether it is a safe read-only operation, leaving gaps.

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

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

The description is two sentences but packs essential information: purpose, input format, costs, and payment instructions. Every clause earns its place, and the POST example is front-loaded for quick 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 percentage calculator with no output schema and moderate parameter count, the description covers the core purpose, input structure, and payment requirement. It lacks explicit definitions for each mode and the exact return format, but for a tool of this complexity it is nearly 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 paymentTx and payerAddress, leaving a, b, and mode undocumented. The description compensates by providing the accepted mode values and an example POST body showing a=120, b=150, which clarifies how these parameters relate. It does not fully explain the meaning of each mode, but the names are self-explanatory in context.

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 defines the tool as 'Percentage maths' and provides a concrete POST example with modes ('change', 'of', 'increase', 'decrease') and numeric parameters, making the function unmistakable. It distinguishes itself from sibling tools by being the only percentage-related tool, and the example removes ambiguity.

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

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

The description gives clear usage context: it costs $0.005 and requires either a paymentTx or payerAddress, directing users to 'how_to_pay' for payment details. It does not explicitly state when to use vs. alternatives, but no alternative percentage tool exists among siblings, so the implicit usage is sufficient.

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

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

The description adds useful behavioral details like the payment requirement (costs $0.01 USDC) and the output format (validity, type, E.164/national/international formats). However, it includes a 'country' parameter in the example that is not present in the input schema, and it does not disclose error behavior or prerequisites. Without annotations, this schema mismatch is a critical transparency gap.

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

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

The description is exceptionally concise, using two sentences to convey purpose, an example, cost, and payment instructions. It is front-loaded with the main purpose and avoids unnecessary filler, making it easy to parse.

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

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

Given the lack of annotations and output schema, the description should provide complete invocation context. It covers purpose, output, and cost, but the example's 'country' field misaligns with the schema, the required parameters are not stated (all optional), and no error handling or return-value details are provided. This leaves the agent with ambiguity that could lead to incorrect calls.

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 leaves 'phone' undocumented (67% coverage), and the description provides an example phone number but no formal format specification. It also introduces an undefined 'country' parameter in the example, contradicting the schema and confusing the parameter contract. The payment parameters are adequately described only by the schema, not the description.

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

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

The description clearly states the tool's function with a specific verb ('Parse and validate') and resource ('a phone number'). It distinguishes itself from sibling validation tools like email_validate by explicitly targeting phone numbers, and the example input/output reinforces the purpose.

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

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

The description provides clear context for when to use this tool: whenever a phone number needs parsing and validation. It does not explicitly mention when not to use it or name alternatives, but the purpose is unambiguous enough to guide selection.

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

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

No annotations are provided, so the description carries the transparency burden. It discloses the cost ($0.01), payment methods (paymentTx or payerAddress), and output formats (SVG string or PNG data URI). While it does not mention error handling or rate limits, the provided behavioral details are useful and go beyond basic functionality.

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 dense sentence covers the request format, output type, cost, and payment instructions. Every phrase adds value, and the information is front-loaded with the core purpose before payment 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?

For a straightforward QR generation tool, the description covers the essential inputs, outputs, cost, and payment path. It lacks explicit defaults for format or requiredness, but the provided context is sufficient for an agent to select and invoke the tool correctly in most 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 only 50% (text and format lack descriptions). The description compensates by defining 'text' as content and 'format' as 'svg'|'png', adding critical meaning. It also clarifies the roles of paymentTx and payerAddress, complementing the schema's brief 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 uses a clear verb ('generation') and specifies the resource (QR code) with exact request/response format. It distinguishes the tool by focusing solely on QR code generation, making it unambiguous among the sibling tools.

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

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

The description states the input structure and output, and explicitly directs users to call 'how_to_pay' for payment details, which is a practical usage guideline. It does not explicitly discuss when not to use the tool, but the payment flow and input requirements are clearly conveyed.

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

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

With no annotations, the description carries the full burden. It discloses the main effect (converting payment to credit) but does not mention potential errors, reversibility, prerequisites beyond 'already made', or whether the action is idempotent. This is adequate but leaves gaps in behavioral disclosure.

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

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

The description is two short sentences with no fluff. It front-loads the main action and includes the necessary input instruction. Every word serves a purpose.

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

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

For a simple single-parameter tool with no output schema and no annotations, the description covers the core purpose and usage. It does not describe return values or error scenarios, but the clarity of the action makes it reasonably complete for an agent to select and invoke correctly.

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

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

The schema description fully covers the only parameter (paymentTx), including that it is a transaction hash on Base. The description adds no extra meaning beyond telling the agent to 'Pass the transaction hash', which is redundant. Baseline 3 is appropriate given full schema coverage.

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

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

The description uses a specific verb 'Turn' and resource 'USDC payment' to clearly state the action. It also mentions the outcome 'credit you can spend across multiple tool calls', which distinguishes it from sibling tools like check_credit and how_to_pay that serve different purposes.

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

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

The description provides clear context: the tool is used after a USDC payment has been made, to convert it into usable credit. This implies the appropriate scenario without explicitly naming alternatives, but it does not mention when not to use it or exclude other tools.

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

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

No annotations are provided, so the description carries the burden. It discloses the cost ($0.005 USDC on Base), payment methods (paymentTx or payerAddress), and return format (matches with groups and indices). It implies a read-only test operation, though it does not detail behavior on invalid regex patterns.

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 action and an example. Every clause is useful—purpose, input format, output, cost, payment—and 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?

For a simple tool, the description covers what it does, input example, cost/payment, and output shape. It lacks details on error cases or flag semantics, but these are not essential for basic usage and the output schema is absent.

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 only 40%, but the description compensates by providing a complete example body mapping text, pattern, and flags, and explicitly explains the payment parameters. This adds meaning beyond the raw 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 opens with 'Test a regular expression and extract matches,' a specific verb and resource. The example POST body with text, pattern, and flags further clarifies the operation. This clearly distinguishes it from sibling utilities like json_query or text_stats.

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 by showing a concrete use case and mentions the payment requirement. It does not explicitly list alternatives or when-not-to-use, but the context is sufficient for most agents to determine 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. It discloses the cost ($0.01 in USDC), the required payment mechanism (paymentTx or payerAddress), and references how_to_pay. It also implies a read-only network operation. However, it does not mention potential timeouts or error conditions, but the added cost/payment context is substantial.

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 and packs essential information: purpose, example, cost, and payment details. It is concise with no filler, though the example is somewhat long. Overall, it 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?

With no output schema and no annotations, the description gives a high-level view of the return (allowed plus sitemaps) but lacks detailed response structure. The path parameter discrepancy creates a completeness gap. Payment information is well covered, but parameter semantics are incomplete for a 4-parameter 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 example includes a 'path' field that is not present in the input schema, causing confusion about available parameters. The description does not explain url/userAgent semantics beyond the example, and paymentTx/payerAddress already have schema descriptions. Schema coverage is 50%, and the description introduces an invalid parameter, so it does not add clarifying 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 the tool fetches and interprets robots.txt, with a concrete example showing the API usage and expected result (whether crawling is allowed, plus sitemaps). This distinguishes it from sibling tools like sitemap_parse.

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 example provides a clear usage pattern, but there is no explicit guidance on when to use this tool versus alternatives (e.g., sitemap_parse) or any exclusions. Usage context is implied rather than explicitly stated.

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

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

With no annotations, the description carries the full burden and adds substantial value by disclosing the cost ($0.02 USDC on Base) and payment requirement (paymentTx/payerAddress). It also outlines the output structure (feed title, items with links/dates). However, it omits error behavior and mutual exclusivity of url/xml.

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 exactly two sentences, front-loaded with the primary purpose, then covers input methods, output summary, cost, and payment instructions without any wasted words. Every clause adds necessary information.

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

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

The description fails to explicitly state that payment is a mandatory prerequisite, does not clarify whether url and xml are mutually exclusive, and leaves the xml parameter undocumented in the schema. Given the absence of an output schema and annotations, more detail is needed, especially around side effects and failure conditions.

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 67% (url lacks description), and the description tries to fill gaps but introduces 'xml' as an input not present in the schema (additionalProperties=false). This is misleading and could cause incorrect invocations. The payment parameter descriptions in schema are adequate, and the description adds cost context, but the xml discrepancy is a significant flaw.

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 'Parse an RSS or Atom feed' with a specific verb and resource. This clearly distinguishes from sibling tools like sitemap_parse or xml_to_json by focusing on feed formats, leaving no ambiguity about its core function.

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?

Implies usage for parsing RSS/Atom feeds, but does not explicitly state when to use this tool over alternatives. It mentions input formats (url/xml) and payment steps, but lacks explicit exclusions or comparisons to sibling tools.

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

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

With no annotations provided, the description carries the full burden. It discloses the $0.02 cost, payment options (paymentTx or payerAddress), and return format. It doesn't mention error behavior or rate limits, but the paid nature and payment flow are 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?

Two sentences: first introduces the tool and output, second covers cost and payment. Every sentence earns its place, and the key purpose is front-loaded.

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 3 params and no annotations/output schema, the description covers purpose, usage, payment, and return type. It could include error handling or rate limits, but it is largely self-sufficient for an agent to invoke correctly.

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

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

Schema coverage is 67% (url lacks description), but the description adds meaning by showing an example URL and explaining the payment parameters. The cost and payment method context enrich the schema descriptions for paymentTx and payerAddress.

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+resource: 'Parse a sitemap.xml (including sitemap indexes)', and clarifies the output as 'URLs with last-modified dates'. This clearly distinguishes it from siblings like rss_parse or xml_to_json.

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 a concrete usage example (POST with url) and explicitly directs users to 'call how_to_pay for details' for payment, which is a sibling tool. However, it does not give explicit when-not-to-use guidance or compare against alternative parsing tools.

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

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

No annotations are provided, so the description carries the burden. It discloses the cost, payment options, and a sample response, and references how_to_pay for further payment details. It does not mention failure modes or whether payment is strictly required, but covers the essential behavior for a paid utility.

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 an example; every part serves a purpose. It includes essential cost/payment information without padding 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 utility, the description covers purpose, example, and payment, and references how_to_pay for details. It lacks explicit error handling or an output schema, but the example output suffices for most cases, making it 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?

The text parameter's meaning is clarified by the phrase 'any text' and the example, compensating for its missing schema description. PaymentTx and payerAddress have schema descriptions, and the description adds their role as alternative payment methods, enhancing clarity.

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

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

The description states 'URL-safe slug from any text' and provides a concrete input-output example, clearly identifying the function as text-to-slug conversion. It differentiates from sibling tools like case_convert and hash by showing a specific transformation and output.

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

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

The description gives a clear usage example and specifies payment requirements, which is relevant context. It does not explicitly compare to alternatives, but its unique purpose among the many utility tools makes the usage context clear enough without exclusions.

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

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

With no annotations, the description must disclose behavior. It does mention the $0.02 cost, payment methods, and output format. However, the example includes a 'port' field not present in the schema, and it doesn't explain behavior when no payment is provided, creating 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 two sentences, front-loaded with the main action, and includes only necessary details about output, cost, and payment. Every sentence contributes 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?

For a simple tool with no output schema or annotations, the description covers the main purpose, expected inputs via example, output fields, and payment mechanics. Missing edge-case behavior and a schema-example mismatch leave some gaps, but it's largely 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 coverage is 67%, with paymentTx and payerAddress already described. The description adds context for domain via the example but introduces a port parameter not in the schema. It doesn't significantly enhance parameter understanding 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 'Inspect a TLS certificate' with a specific verb and resource, and provides the output fields (issuer, subject, validity dates, days until expiry). This distinguishes it from sibling tools like dns or whois.

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 via a POST example and explains the payment requirement. It does not explicitly state when not to use it or name alternatives, so it's clear but lacks exclusions.

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

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

Despite no annotations, the description discloses critical behavioral traits: the cost ('Costs $0.005 in USDC on Base'), the required payment method ('pass paymentTx or payerAddress to pay'), and a pointer to how_to_pay for further details. This goes beyond what the schema provides and alerts the agent to the paid nature of the operation. However, it does not mention potential failure modes or rate limits.

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 concise sentences with no filler. It front-loads the core purpose ('Text statistics'), then provides a compact example, output list, and payment info. Every sentence earns its place.

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

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

For a simple tool with no output schema, the description covers the input format, expected outputs, and payment requirements, and appropriately defers to how_to_pay for billing details. It could be slightly more explicit about the exact JSON response structure, but overall it is sufficient for an agent to decide whether and how 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 67%, with 'text' lacking a description. The tool description compensates by showing the exact POST body format ('{"text": "..."}') and listing the computed outputs, which clarifies the text parameter's meaning. The payment parameters already have schema descriptions, so the description adds minimal extra value there.

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 'Text statistics' and provides a concrete input-output mapping: 'POST {"text": "..."} -> characters, words, sentences, paragraphs, reading time, top words.' This distinguishes it from sibling tools like case_convert or base64, which focus on transformation rather than statistical analysis.

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 explicit guidance on when to use this tool versus alternatives like word_frequency. The only directive is 'call how_to_pay for details,' which pertains to payment, not tool selection. This leaves the agent to infer usage context without clear boundaries or exclusions.

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

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

With no annotations, description discloses cost ($0.005), payment mechanism, and output types. Lacks error/edge-case info but offers important behavioral context beyond a bare read-only hint.

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?

Three sentences front-load purpose, include a working example, and mention cost/payment — no wasted words.

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

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

Covers input formats, output types, cost, and payment. Lacks response structure and default timezone behavior, but adequate for a simple conversion tool without 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 only describes paymentTx/payerAddress; description fills the gap for value and timezone via examples, defining accepted formats and timezone example. Adds significant meaning beyond 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?

Clearly states 'Convert timestamps and dates' and provides concrete examples of input/output, distinguishing it from siblings like date_diff and cron_parse.

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 a clear invocation example and payment prerequisite, establishing when to use. Doesn't explicitly contrast with alternatives, but context is sufficient.

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 and does well: it discloses the cost, payment mechanism, HTTP method (POST), and the expected output. It doesn't cover error behavior or what happens with invalid tokens, but the key behavioral aspects—especially the paid nature—are transparently communicated.

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 core purpose ('ERC-20 token metadata'), followed by a concrete example and payment instructions. Every sentence adds distinct value, with no redundancy or fluff.

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

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

Given the lack of output schema and annotations, the description provides strong coverage: input example, output fields, cost, payment methods, and a pointer to how_to_pay. It omits error handling and edge cases, but for a straightforward metadata query tool, this is sufficiently 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 coverage is 50% (only paymentTx and payerAddress have descriptions). The description compensates by explaining the token and chain parameters via the example: token is the contract address ('0x...') and chain is the chain name ('base'). This adds meaning beyond the schema, while the schema already covers the payment parameters.

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

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

The description clearly states the tool's purpose with a specific verb and resource: 'ERC-20 token metadata.' It provides an explicit example request and lists the return fields (name, symbol, decimals, total supply), making it unambiguous and distinct from sibling tools like metadata or wallet_balance.

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 clear context on prerequisites (costs $0.015 in USDC, requires payment via paymentTx or payerAddress) and directs users to how_to_pay for details. While it doesn't explicitly mention exclusions or alternatives, the purpose is so well-defined that when to use it is implied. This meets the 'clear context, no exclusions' level.

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

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

With no annotations, the description carries the full burden. It discloses that the tool is free and uses the real CLIP model, but it does not describe what the sample image is, what output is returned, or any limitations. Since it is a simple no-parameter tool, the lack of detail is understandable but still leaves behavioral aspects 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?

A single sentence that front-loads the 'Free' aspect and immediately states the function. Every word earns its place, 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 tool's simplicity, the description covers the essential who-what-why. It does not describe the output format, but with no output schema, adding that detail could improve completeness. Still, for a free sample tool, this is largely adequate.

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