Penniless Data Utilities

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

With no annotations, the description carries the full behavioral burden. It discloses the output shape ({ok, next, epochMs}), the UTC basis, supported cron features, and a distinctive side effect: a $0.001 USDC cost on Base per call. It does not mention invalid-expression error behavior, but otherwise gives solid behavioral context.

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 short sentences, each earning its place: the core computation, the request/response body shape, and the cost. The most identifying information is front-loaded in the first sentence.

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

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

Given the output schema exists and the description already names the response fields, the definition is nearly complete. The main gaps are error behavior and execution details for the paid Base transaction, but the cost disclosure plus input/output summary cover the essentials.

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

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

The input schema already covers both parameters at 100%, including the 'after' default. The description adds little beyond calling expr a '5-field cron expression' and echoing 'after?' in the body format, so it does not meaningfully improve on 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 uses a specific verb ('Computes') and resource ('next UTC fire time for a 5-field cron expression'), and enumerates supported syntax features. This clearly differentiates it from all sibling tools, which are unrelated utilities like DNS lookup and email validation.

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 purpose is so specific that an agent can infer when to use it: whenever a cron schedule's next fire time is needed. It provides clear context but no explicit exclusion or alternative routing; however, none of the sibling tools compete with this function.

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 burden of behavioral disclosure. It usefully communicates the cost ('Costs $0.001 USDC on Base per call') and the response shape, but it does not mention error conditions, rate limits, payment prerequisites, or that a network/paid call is made.

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 dense sentences cover purpose, supported record types, request/response shape, and cost. Every clause is informative, and the core purpose is front-loaded before the payment note.

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

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

The definition is adequate for a simple lookup: it names input and output shapes and discloses cost. However, it omits practical call context such as how payment is handled, error behavior, and when to choose this over the sibling domain_whois, which leaves some gaps for an agent.

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

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

Schema description coverage is 100%, so the schema already documents both parameters and the default value. The description adds little beyond restating the body shape ('Body {domain, type?}'), which is already implied by 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 a specific verb ('lookup') and resource ('DNS-over-HTTPS lookup' for a defined set of record types), making the core function obvious. It is distinguishable from the sibling domain_whois by its focus on DNS records rather than registration data, though it does not explicitly name the alternative.

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

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

No guidance is given about when to use this tool versus alternatives like domain_whois. The description implies it is for resolving DNS records, but it provides no exclusions, prerequisites, or explicit use-case 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 behavioral burden and usefully discloses the per-call cost ($0.001 USDC on Base) and the structured ok/found response shape. It does not mention failure modes, rate limits, or behavior for invalid or unregistered domains, 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 three dense sentences: it front-loads the purpose and returned fields, then gives the response shape and cost. There is no filler or repetition of schema 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 one-parameter lookup with an output schema, the description covers the key operational facts: input, response fields, and cost. The main omissions are error/not-found behavior and caveats about RDAP coverage, but these are minor for this 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?

The schema already fully documents the single domain parameter with 100% coverage, so the baseline of 3 applies. The description's mention of 'Body {domain}' adds little 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 a WHOIS lookup via RDAP and enumerates the returned fields (registrar, IANA id, statuses, dates, nameservers, DNSSEC), making the tool's purpose concrete. It does not use an explicit verb like 'retrieves' or differentiate itself from dns_lookup, so it falls just short of a 5.

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

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

The listed fields and 'for any domain' imply the tool is for domain registration metadata rather than DNS resolution, so usage is inferable. However, it never explicitly says when to prefer this over dns_lookup or any alternative.

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 disclosure burden. It explains the two-step behavior (RFC syntax check + live MX probe), specifies the exact output format, and discloses the per-call cost of $0.001 USDC on Base. It does not mention side effects (e.g., whether it writes anything), but as a validation check it is implicitly read-only; the cost is a notable side effect that is 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 two sentences with no filler. It front-loads the core purpose, then immediately gives the output format and cost—key factual details that an agent needs. Every sentence earns its place, and the structure is crisp.

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

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

For a single-parameter tool with an output schema (which likely documents return fields), the description sufficiently covers the behavior (syntax + MX) and cost. It does not explicitly mention timeout, error conditions, or prerequisites like network access, but these are likely handled by the output schema or general runtime context. It is complete enough for an agent to call the tool correctly.

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

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

Schema coverage is 100% since the only parameter 'email' has a description ('Email address'). The tool description adds no extra information about the parameter—it does not provide format examples, normalization rules, or edge cases. Baseline 3 is appropriate because the schema already documents the single parameter adequately.

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

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

The description states a specific verb and resource: 'Email deliverability check' with details on RFC syntax and MX probing. It clearly distinguishes itself from sibling tools like dns_lookup or domain_whois, which are generic DNS or WHOIS lookups, not email-specific validation. No ambiguity about what it does.

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

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

The description implies usage for email deliverability validation, giving clear context. However, it does not explicitly mention alternatives or when not to use it. Since none of the sibling tools overlap in purpose, the agent can infer the correct scenario without explicit exclusion 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?

No annotations are provided, so the description carries the full burden. It discloses the output body structure and the cost ($0.001 USDC per call), which is useful. However, it does not mention failure modes (e.g., repo not found), rate limits, or whether any authentication is required. The cost disclosure is a positive, but the description could be more transparent about error handling.

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

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

The description is two concise sentences. The first sentence states purpose and lists output fields, and the second gives the body format and cost. It is front-loaded and 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 tool with one parameter and an output schema, the description covers the purpose, output structure, and cost. It does not explicitly state error handling or rate limits, but the 'found' field implies handling of missing repos. Given the low complexity, it is nearly complete, though a note on invalid repos would make it 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 description covers the only parameter 'repo' with 'owner/name', which is clear. The description adds no additional semantics beyond the schema, only showing how it appears in the body. Since schema coverage is 100%, the baseline of 3 applies.

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

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

The description clearly states the tool returns popularity and metadata for any public GitHub repo, listing specific fields (stars, forks, open issues, etc.). This is a specific verb+resource with no ambiguity, and it is clearly distinct from its unrelated siblings (cron, DNS, WHOIS, etc.).

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 specifies the tool is for any public GitHub repo, providing a clear scope. While it does not explicitly mention alternatives or when not to use it, the sibling tools are entirely unrelated (cron, DNS, email, JSON tools), so no alternative routing is needed. The context is sufficient for an agent to know when to invoke this tool.

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

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

With no annotations provided, the description carries the full behavioral burden and does so well: it discloses what transformations the tool applies, that it returns {ok, repaired, applied}, and that each call costs $0.001 USDC. There is no contradiction with annotations.

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 dense sentences deliver a complete picture: core purpose, concrete behaviors, return envelope, and cost. The most important information is front-loaded and no sentence is 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 a single required string parameter, an output schema, and clear sibling boundaries, the description covers input form, behavior, return structure, and cost. It does not elaborate on edge cases like already-valid JSON, but the output schema and focused scope make that unnecessary 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 100% since the only parameter, 'input', is described as 'Malformed JSON text', so the baseline is 3. The description adds meaningful extra semantics by specifying the kinds of malformed content the tool handles, including Markdown fences, prose wrappers, Python literals, and unquoted keys, which helps agents determine whether their input qualifies.

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 ('Repairs') and a clear resource ('malformed LLM JSON'), then enumerates concrete transformation behaviors such as stripping Markdown fences, fixing trailing commas, and converting Python literals. This makes the tool immediately distinguishable from siblings like text_diff and yaml_to_json, 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 intended use case is embedded in the first sentence: repair malformed LLM JSON. The enumerated malformations give an agent a clear trigger condition, and the cost note sets an operational expectation. It doesn't explicitly state when not to use it or name alternatives, but none of the siblings are close enough substitutes to create confusion.

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 pricing per call, the input/output payload shape, the use of LCS line diffing, the 'identical' flag behavior, and the returned fields, which is substantial transparency for an unannotated 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 dense sentence that packs a lot of purpose, algorithm, request/response shape, and cost information. It is not visually structured, but it is concise and every element contributes meaning.

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

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

The tool is simple, has only three documented parameters, and provides an output schema. The description adds the algorithm, response fields, and cost model, making it operationally sufficient. It could still mention failure modes or expected request limits, but 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?

Schema coverage is 100%, so the schema fully documents old, new, and context. The description adds little beyond restating 'context?' in the body format and mentioning configurable context lines, which is useful but does not substantially increase semantic 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 uses a specific verb and resource: 'Produces a unified diff plus added/removed counts between two texts.' It clarifies the method (LCS line diff) and the optional context-lines parameter, making the tool's purpose distinct from 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 clearly implies the tool is for comparing two text bodies and getting a unified diff with line counts Poisson. However, it does not explicitly state when to prefer this tool over alternatives, nor does it mention exclusions such as very large texts or unsupported line-ending styles.

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 it does well by disclosing the output shape ('{ok, source, title, headings, links, urls, emails, text}') and the per-call cost. It stops short of detailing error behavior or edge cases, but the core behavioral contract is visible.

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 compact sentences deliver the core function, input domain, output shape, and cost without fluff. The most important information is front-loaded, and every phrase contributes useful guidance.

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

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

Given the simple 3-parameter schema and the presence of an output schema, the description is largely complete. It even adds cost information that is not present elsewhere. It could be more complete by noting any size limits or failure modes, but nothing essential is missing for a straightforward extraction call.

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

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

Schema coverage is 100%, so the schema already documents all three parameters. The description lists the request body shape but adds no meaning beyond what the schema property descriptions already provide, so the baseline of 3 is appropriate.

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

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

The description states a specific verb ('Extracts') and a precise resource ('clean text, title, headings, links, URLs, and emails from HTML or plain text'). This clearly differentiates it from siblings like dns_lookup or repair_json. The purpose is unambiguous and immediately actionable.

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

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

The description makes the input domain explicit ('from HTML or plain text'), which tells an agent when this tool is appropriate. It does not name sibling alternatives or state when not to use it, but the scope is clear enough to avoid obvious misuse.

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 adds meaningful details: the call body shape ({input} -> {ok, value, warnings}), the limitation to a YAML subset, the lack of runtime dependency, and the per-call cost on Base. This goes well beyond a bare verb phrase, though it doesn't cover how invalid input is handled beyond warnings.

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 tight sentences, each earning its place. The core conversion action and scope are front-loaded, followed by the output envelope and cost. No filler or redundancy.

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

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

For a one-parameter tool with an output schema present, the description covers the essential operational details: input format, supported YAML subset, output shape with warnings, and cost. Nothing critical is missing for an agent to invoke it correctly.

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

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

Schema description coverage is 100% because the single 'input' parameter is already documented as 'YAML document text'. The description reinforces the body shape and YAML scope but adds little new semantics beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Converts') with a clear resource ('YAML subset ... into JSON'), and even enumerates the supported YAML features (block maps, sequences, nested indentation, scalars, comments). This makes the tool's purpose immediately understandable and distinct from its siblings such as repair_json or text_extract.

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 this tool is appropriate: when a YAML document needs to be converted to JSON. It doesn't explicitly discuss alternatives or exclusions, but the context is clear enough that an agent can infer the primary use case without ambiguity.

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