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 call is unauthenticated and fully specifies the return shape (dict keys). It does not explicitly declare side-effect-free behavior, but the read-only nature is strongly implied by the content and the 'before start_checkout' guidance.

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?

At three short sentences plus a key list, the description is appropriately compact and front-loads the core answer (returned fields) before usage guidance. The opening is a slight sentence fragment, but it is not padded and every line contributes.

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 parameterless tool with no output schema and no annotations, the description is fairly complete: it covers when to call, authentication status, and the exact return keys. It omits only minor details such as error behavior or units for topup_usd, which are inferable from the key names.

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?

There are zero parameters, so there is nothing for the description to add beyond the schema. The baseline for a parameterless tool is 4, and the description does not introduce any parameter 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 identifies the resource (account options) and the data returned (purchases_enabled, topup_usd, free_tier_calls, billing_url, checkout_path). The opening phrasing is a grammatical fragment rather than an explicit verb, which costs a point, but the return list makes the operation clear. It is distinguishable from siblings like account_usage and start_checkout.

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 explicitly states when to use it: 'Call this (or read a 402 body) before start_checkout.' It also flags that the endpoint is unauthenticated, which tells the agent no auth setup is needed, and offers a concrete alternative path (reading a 402 body).

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 full responsibility. It discloses a key behavioral outcome (402 payment_required when limits are exhausted) and the return shape. However, it does not explicitly state that the call is read-only and has no side effects, which would be valuable given the absence of annotations. The description is helpful 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?

The description is compact and front-loaded with the purpose, followed by a concrete usage tip and a list of return keys. Every sentence earns its place, with no redundancy or fluff. It is optimally sized for quick comprehension.

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 zero-parameter, read-only usage check with no output schema, the description provides the essential information: what it returns, when to call it, and what a failure (402) means. Nothing an agent needs to invoke it correctly is missing, especially given the simplicity of 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 tool has zero parameters and the schema is empty, so there is no parameter semantics to add. The baseline for 0-parameter tools is 4, and the description correctly adds no parameter information while providing context about the expected return dictionary, which is the relevant semantic content.

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 resource and action: 'Current-month usage and prepaid balance for this API key.' It clearly distinguishes from all sibling tools, none of which cover usage or billing. The phrasing is concrete and unambiguous, leaving no need to infer the tool's role.

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?

Gives an explicit when-to-use cue: 'Call this before a bulk loop.' It also explains the meaning of the 402 error, which helps the agent decide whether to proceed. However, it doesn't mention alternatives or when not to use it, though no sibling tool serves a similar purpose, so that omission is minor.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the return format ('dict with keys: url'), the time-limited nature of the URL ('expires after a few minutes'), and the failure mode ('null + note if Stripe not configured'). It does not mention side effects or permission requirements, but for a zero-parameter tool this is strong coverage.

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: purpose, then usage guidance, then return behavior. Every sentence earns its place and there is no redundant 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 parameterless tool with no output schema, the description is complete: it explains what it does, when to use it, what it returns, and what happens when Stripe is not configured. Nothing essential is missing for an agent to call it correctly.

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

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

The tool has zero parameters and an empty schema, so the baseline is 4. The description adds relevant context about the implicit 'current API key' without needing to document any 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 states a specific verb and resource: 'Open a Stripe Billing Portal session for the current API key.' This is clear and unambiguous. However, it does not explicitly contrast with sibling tools such as start_checkout, so the differentiation is implied rather than stated.

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 contexts: 'Use this when the user wants to update their payment method, cancel, or download invoices.' This gives an agent clear conditions for invoking the tool, although it does not mention when not to use it or name 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 available, the description carries the behavioral burden and does so well: it discloses method selection (GET for certain paths), body handling for POST vs GET, and the three possible return shapes. It does not cover rate limits, authentication, or side effects, but for a generic passthrough this is meaningful disclosure beyond the schema.

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

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

The description is well-structured with an opening purpose statement, an Args section, and a Returns section. Every sentence earns its place, and concrete examples are provided without padding.

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 generic 2-parameter passthrough with no output schema, the description covers input semantics, method behavior, and return variants, and even flags that routes are billed. It could add a note on error handling or endpoint validity, but it is largely complete for an agent to call the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It does: 'path' is explained with concrete examples and 'body' is defined as the JSON object expected by the REST API, with an example and the note that it is ignored for GET. This adds substantial meaning beyond the raw schema, though it cannot enumerate every possible endpoint body.

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 first sentence states a clear verb ('Call'), a specific resource ('billed catalog route or account endpoint'), and the mechanism ('by path'). The phrase 'Closes MCP coverage gaps without a dedicated wrapper' distinguishes it from the many sibling tools that wrap specific endpoints.

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 explicitly positions this as the fallback for endpoints without a dedicated wrapper, which is a clear when-to-use rule. It adds routing detail that GET is automatic for /v1/catalog and /v1/account/usage|options, and that body is ignored for GET, though it does not fully enumerate when to prefer specific 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 to lean on, the description fully discloses critical behavioral traits: it uses the HaveIBeenPwned k-anonymity API, sends only the first 5 characters of the SHA-1 hash, never lets the plaintext password leave the server, and never logs or stores the password. This is exactly the kind of privacy-critical transparency that matters for a password-handling 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 efficient and well-structured: a clear one-line purpose, a focused privacy note, and concise Args/Returns sections. Every sentence provides necessary information, and the most important scoping detail 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?

The tool has one parameter and no output schema, so the description correctly includes the return keys to tell the agent what to expect. It could add details about error handling or rate limits, but for a single-parameter utility, the provided information is sufficient 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?

The schema only defines password as a required string with no description, so the description must compensate. It does so by explaining the password is the value to check and emphasizing it is never logged or stored. This adds meaningful behavioral context beyond the bare 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 and resource: 'Check if a password has appeared in known data breaches and assess its strength.' It distinguishes itself from sibling tools like generate_password or enrich_* by focusing on breach checking and strength assessment.

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 first sentence makes the tool's intended use obvious: when an agent needs to verify whether a password is breached and gauge its strength. No explicit 'when not to use' or alternative routing is provided, but no sibling tool performs the same function, so implied 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?

With no annotations provided, the description carries the full burden and handles it well. It discloses that classification is heuristic, not ML-based, lists exactly what is scored, and enumerates the return keys including method, scores, language, and cost. It does not dig into score ranges or error behavior, but the core behavioral caveat is clearly surfaced.

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, well-organized, and front-loaded. The first line gives purpose, the second line adds an important caveat, and the Args/Returns sections provide structured details without fluff. 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 one-parameter tool with no output schema, the description covers the essential invocation context: input, length recommendation, method, and return keys. Minor omissions such as score ranges or the meaning of 'optional langdetect language' prevent a perfect score, but nothing critical blocks correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It does by explaining that 'text' is the piece of text to classify and by adding a practical constraint: 'up to ~5,000 characters recommended.' This goes beyond the schema's bare string type and is sufficient for a single-parameter tool.

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

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

States a specific verb and resource: 'Classify a piece of text with keyword heuristics.' It also lists the classification dimensions (sentiment, toxicity, spam, language) and explicitly notes it is not a trained NLP or toxicity model. However, it does not directly differentiate itself from the sibling tool filter_profanity, relying instead on the general purpose being clear.

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

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

The description implies usage through the caveat 'Not a trained NLP or toxicity model' and 'keyword heuristics,' suggesting it is for lightweight, explainable classification rather than high-accuracy ML tasks. It does not explicitly state when to use this tool versus alternatives or name any sibling tools as better fits for specific 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 and does well: it discloses the data source (ECB via frankfurter.dev), the 1-hour cache, and the exact return keys. The inclusion of cost_usd hints at cost behavior, but it does not explain error handling or the meaning of that field, leaving a small 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 efficiently structured: a one-sentence purpose, two short sentences about data source and caching, then Args and Returns sections. Every sentence adds necessary value, and the front-loaded purpose helps agents quickly understand what the tool does.

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 is largely complete: it covers the operation, all parameters, and the return structure. Minor omissions—undefined cost_usd, the overbroad 'any two currencies' claim, and no error scenarios—prevent a perfect score but do not block correct invocation.

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

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

Schema description coverage is 0%, so the description fully compensates with an Args section that explains each parameter's meaning, provides ISO 4217 format guidance, and gives concrete examples for all three parameters. This is exactly what an agent needs to construct valid arguments.

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 'Convert an amount between any two currencies', a specific verb+resource statement that clearly identifies the function. Naming ISO 4217 currency codes and the distinction from sibling tools like convert_units and convert_timezone makes the tool's domain unmistakable.

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

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

The description gives clear context by stating the conversion scope and adding behavioral details about ECB rates and caching, which indicate when the tool is appropriate. However, it does not explicitly mention alternatives or when not to use it, though the sibling list makes those alternatives discoverable.

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. It discloses the conversion scope, the supported syntax, and the exact return keys including html and cost_usd. It does not discuss sanitization, raw HTML handling, or limits, but for a pure conversion utility this is reasonably transparent.

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

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

The description is front-loaded with the core purpose, uses a compact feature list instead of prose, and has clearly labeled Args and Returns sections. Every line contributes actionable information without padding.

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 a single trivial parameter and no output schema, so the description sufficiently explains input and return values. It could be more complete by stating whether the output is an HTML fragment or full page and whether unsupported Markdown is silently ignored, but these are not blocking gaps for a single-argument utility.

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

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

The schema only defines markdown as a required string with 0% description coverage. The description compensates by adding 'markdown: Raw Markdown string' and the main description qualifies what kinds of Markdown are accepted. This adds useful meaning beyond the bare 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 a specific verb and resource: 'Convert a Markdown string to HTML.' It additionally enumerates the supported Markdown elements, which makes the tool's scope concrete and clearly differentiates it from the other convert_* siblings.

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 this tool is for Markdown-to-HTML conversion and lists the constructs it handles, giving an agent enough context to choose it. It does not explicitly state when not to use it or name alternatives, but no direct Markdown-conversion sibling exists, so the omission is minor.

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 DST awareness, IANA database usage, no external API, and output keys including cost_usd. However, it does not explain cost_usd semantics, error cases, or side effects.

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

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

Two-sentence summary followed by structured Args and Returns sections. No fluff, purpose is front-loaded, and every sentence contributes useful information.

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

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

For a tool with no output schema, the description lists output keys but not value types or semantics (notably cost_usd). It also lacks error-handling info, leaving gaps for an agent to fully self-serve.

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

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

Schema coverage is 0%, so the description fully compensates. It provides format and examples for datetime, and IANA timezone examples for from_tz/to_tz, adding meaning far beyond the plain string type in 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?

Clear verb 'convert' with a specific resource 'datetime from one timezone to another', plus DST-aware adds specificity. It distinguishes itself from sibling converters like convert_currency and convert_units.

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

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

No explicit when-to-use, exclusions, or alternative routing. The description implies usage through its purpose, but among many sibling converters it offers no 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, the description carries the full responsibility for behavior. It clearly states that category is auto-detected from unit names, explains that category is optional, and enumerates the return dictionary keys. This gives a solid account of what the tool does and what the caller can expect.

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 well-structured: a one-sentence purpose, a one-line supported-category summary, an auto-detection note, then Args and Returns sections. Every sentence earns its place with no filler or redundant restatement of the tool name.

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

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

The description provides enough to call the tool correctly: all parameters are explained and the return shape is listed despite no output schema. It does not list all supported unit strings or failure behavior for invalid/cross-category conversions, so it is not fully exhaustive, but it is complete for typical usage.

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

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

Schema description coverage is 0%, but the description fully compensates by documenting every parameter with meaning and examples: value, from_unit ('km', 'kg', 'celsius'), to_unit ('mi', 'lb', 'fahrenheit'), and the optional category. It also clarifies the auto-detection behavior, adding value well beyond the bare 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 a specific verb and resource: 'Convert a value between units of measurement.' It then enumerates the supported categories (length, weight, temperature, area, volume), which clearly distinguishes it from sibling tools like convert_currency and convert_timezone.

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 this tool by listing supported measurement categories, but it does not explicitly name alternative tools or state when not to use it. The sibling context includes convert_currency and convert_timezone, but the description never calls these out or provides exclusion criteria.

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

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

With no annotations provided, the description carries full burden and handles it well. It discloses key behavioral traits: exact counts for OpenAI, ±10% approximation for other models using cl100k_base, estimated input prices with an as_of date, and the exact return key structure. The user can predict what the tool does and its accuracy 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 longer than average due to the supported-model enumeration, but every section earns its place: purpose, return value summary, model list, algorithm notes, and parameters. The core behavior is front-loaded, and the organization makes it skimmable.

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 annotations and no output schema, the description provides everything an agent needs: purpose, supported models, approximation behavior, pricing caveat, and a full return-key list. The model list is future-proofed with aliases, and the mention of 'as_of' prevents misuse of stale prices.

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

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

Schema description coverage is 0%, but the description includes an Args section that explains both parameters: text ('The text to count tokens for') and model ('LLM model name (default "gpt-4o")'). It even lists acceptable model values, fully compensating for the sparse 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 a specific verb and resource: 'Count the tokens in text for any major LLM model.' It clearly distinguishes the tool from its utility siblings (e.g., convert_units, generate_hash) by stating its domain—LLM token counting for prompt engineering. The supported model list further reinforces the exact scope.

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

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

The description explicitly names core use cases: 'Essential for prompt engineering, RAG chunk sizing, and context window management.' It doesn't enumerate when not to use the tool or name direct alternatives, but given the sibling list contains no competing token-counting tool, this is sufficient context for selection.

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

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

With no annotations, the description carries the full burden and it largely succeeds: it states the computation behavior, supported aliases, UTC interpretation of from_iso, and the return structure. It does not explicitly say the operation is side-effect free or describe error behavior, but for a pure computation tool the disclosed details are sufficient.

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 well-structured and efficient: a one-sentence purpose, a short alias note, then labeled Args and Returns sections. Every sentence is informative and there is no repetition of schema information beyond what is useful.

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

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

For a three-parameter, no-output-schema tool with no annotations, the description is complete: it explains the input format, defaults, constraints, and the exact return keys. The only omitted details (e.g., invalid-expression error behavior) are minor for this utility class and do not hinder correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It fully documents all three parameters: expression includes a standard cron example and alias support; from_iso specifies ISO-8601/UTC and default 'now'; count states numeric range and default. This adds substantial meaning beyond the bare 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 begins with a specific verb and resource: 'Compute the next N runs of a 5-field cron expression.' This clearly states what the tool does and distinguishes it from the sibling utilities (e.g., convert_timezone, lookup_timezone) which handle different time-related tasks. Including alias support examples further clarifies the scope.

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

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

The description implies usage by defining the tool's purpose and arguments, and provides clear context such as UTC starting point and count range. It does not explicitly name alternative tools or state when not to use it, but none of the siblings overlap with cron computation, so the absence of an explicit exclusion is not a significant gap.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, and it does so well. It explains the return shape with specific keys, including input_bytes, output_length, cost_usd, and an error fallback. This gives the agent a realistic view of what to expect, though it could further describe edge cases such as decoding invalid input.

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

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

The description is well-structured with clearly separated sections for supported codecs, arguments, and return values. It is front-loaded with the core purpose. There is minor redundancy: the codec list appears both in the 'Supports' line and in the codec parameter description, but this is acceptable for clarity.

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

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

Given the simple three-parameter tool, absent annotations, and missing output schema, the description is nearly complete. It documents all arguments, enumerates acceptable values, and describes the return dictionary. The remaining gaps are minor, such as not stating the default values for codec and operation, though those defaults are visible in the schema itself.

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 provides no descriptions (0% coverage), so the description must compensate. It does: each parameter has a meaningful explanation, the codec values are enumerated, and the operation values are defined. The description could add more nuance around each codec's behavior, but it fully covers the basics and goes 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 a specific verb and resource: 'Encode or decode a string' using a common encoding scheme. It lists the supported codecs and the dual operation modes, making it easy to distinguish from sibling tools like generate_hash or parse_url. The name is reinforced without being tautological.

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

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

No explicit guidance about when to choose this tool over alternatives is provided. The description implies usage through the list of supported codecs and operations, but it does not mention exclusions, prerequisites, or when a sibling tool would be more appropriate. An agent must infer the tool's scope entirely from the generic 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 burden of behavioral disclosure. It does reveal the normalization behavior (title-case, regex check) and a key limitation ('not USPS validation or geocoding'), plus the presence of cost_usd in the return. However, it does not explicitly state whether the operation is read-only, requires authentication, or has side effects, which an agent might need to know for a cost-incurring external API.

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 well-organized: a two-sentence purpose statement, followed by a clearly labeled Args list and Returns list. Every sentence earns its place – the exclusions, parameter formats, and return keys are all high-value. There is no filler or redundant 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 no output schema and no annotations, the description does well by listing the return keys (normalized, us_zip_valid, one_line, method, geocoded, usps_validated, cost_usd) and stating the main limitations. It leaves minor gaps such as behavior for non-US countries (does the ZIP regex only apply when country is US?) and error handling, but for a 5-parameter enrichment tool the essentials are covered.

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

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

The schema has 0% description coverage – only types and defaults. The description compensates fully by providing an Args section that explains each parameter's meaning and format: street with an example, state as abbreviation, country as ISO code, and postal_code as ZIP or postal code. This gives an agent everything needed to populate arguments correctly 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 a specific verb and resource: 'Normalize a postal address.' It also states the two key operations (title-casing and ZIP code regex check) and explicitly excludes USPS validation and geocoding, which differentiates it from sibling tools like lookup_postal_code and any geocoding-related utility. This 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 provides clear context for when to use the tool (to normalize and format address components) and an explicit when-not: 'This is not USPS validation or geocoding.' It stops short of naming alternative sibling tools (e.g., lookup_postal_code) that would handle those excluded cases, but the exclusion itself is actionable and prevents 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 behavioral burden and does it thoroughly: it distinguishes syntax validity from MX presence from actual deliverability, explicitly notes that deliverability_checked is always false and likely_deliverable is always null, and discloses the DNS-over-HTTPS mechanism. This prevents the agent from over-trusting the result.

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

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

The description is well-structured with summary, caveat, arguments, and return keys, and the most important scoping information is front-loaded. The return-key list is long, but it earns its place because there is no output schema.

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

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

For a two-parameter tool with no output schema and no annotations, the description covers inputs, outputs, a cost key, and a critical caveat. Minor gaps remain: semantics of similar return fields are not fully clarified, and error or network-failure behavior is not mentioned.

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

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

Schema description coverage is 0%, so the Args section is essential and delivers: it gives a concrete email example and precisely explains check_mx's default behavior and effect. Both parameters are documented with 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 a specific verb and resource—'Validate and enrich an email address'—and elaborates with concrete behaviors: syntax validation, optional MX lookup, and disposable/free-provider flagging. The singular 'an email address' also makes clear this is a single-address tool, distinct from the batch 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 implies the tool is for validating individual email addresses and provides a useful caveat that MX presence does not guarantee mailbox existence. However, it never states when to prefer this tool over enrich_email_batch, validate_domain, or other sibling tools, and gives no exclusion criteria.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does so thoroughly: billing per item, MX lookup deduplication across domains, the honesty caveat that MX presence does not guarantee a valid mailbox, and the exact return structure including error format. This goes beyond a typical description.

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

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

The description is well-structured with an intro, an Args section, and a Returns section. Every sentence adds value: the billing note, the honesty note, the dedup note, and the return keys. No wasted words. The most important usage information 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 batch tool with two parameters and no output schema, the description is complete. It defines parameter ranges, default behavior, return keys, error format, and cost implications. An agent can invoke it correctly without further lookup. The only missing piece (auth, rate limits) is likely handled at a platform level and not required here.

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

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

Schema coverage is 0%, so the description must explain the parameters. It does: 'emails: 1–100 email addresses' adds the count constraint, and 'check_mx: When true (default), perform MX DNS lookups (deduped by domain)' adds behavior and default. This is exactly the kind of semantic enrichment the schema lacks.

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: 'Validate up to 100 emails in one call.' It immediately distinguishes this from the single-email enrich_email tool by the batch capability. The purpose is unambiguous.

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

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

The description implies when to use this tool (when you have multiple emails) and references enrich_email as the comparable single-item tool ('Same honesty as enrich_email'). It does not explicitly state 'use this instead of enrich_email for batches,' but the batch limit and per-item billing make the usage context clear. No explicit alternatives are named beyond the sibling list, but the 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 present, the description carries the full behavioral disclosure burden and meets it well. It reveals provider selection logic, local handling of private/loopback addresses, and crucially states that vendor failures produce error=geolocation_unavailable with null coordinates and never invented lat/lon.

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 front-loaded with a one-sentence purpose, then uses clear Args and Returns sections. Every sentence adds meaningful information: provider behavior, failure semantics, accepted input, and return keys. There is 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?

Given a bare schema, no output schema, and no annotations, the description is unusually complete. It defines the input format, the output dictionary keys, the error behavior, and even the cost_usd key, leaving no critical gap for an agent attempting to call or interpret the result.

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

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

The schema only provides 'ip' as a string with no description, so the description fully compensates by specifying IPv4 or IPv6 format and giving a concrete example, '8.8.8.8'. For a single required parameter, this is exactly the semantic support an agent needs.

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 pair, 'Geolocate an IP address', and the enrichment-focused context is unmistakable. It clearly distinguishes this tool from sibling tools like enrich_email or enrich_phone by naming the target resource and 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 intended use is clear: call this tool when you need to geolocate an IP address. It also gives conditional context by distinguishing public IP handling, private/loopback classification, and vendor failure behavior, though it does not explicitly discuss when-not-to-use or name alternative tools.

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

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

With no annotations, the description carries the transparency burden and does disclose the core behavior: normalizing, validating, detecting line type, and returning a structured dict. A small inconsistency exists because it says 'returns the carrier region' while the documented return keys are country_code and line_type, not an explicit carrier_region key.

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 summary is one tight sentence, followed by concise Args and Returns sections. There is no filler or repetition, and the most important information 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?

Given no annotations and no output schema, the description covers purpose, parameters, and the returned dictionary well. It falls slightly short on edge-case behavior, such as exactly what happens for invalid numbers beyond a 'valid' flag, and it never fully reconciles 'carrier region' with the listed return keys.

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

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

Schema description coverage is 0%, so the description must compensate, and it does. It explains that phone accepts any format with illustrative examples, and country_hint is documented as an ISO 3166-1 alpha-2 code with default 'US' and the rule for when it 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 opens with a specific verb and resource: 'Parse and validate a phone number.' It then names concrete enrichments (E.164 normalization, line type detection, carrier region) that distinguish it from sibling tools like enrich_email and enrich_address.

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 establishes the tool's context: it is for processing phone numbers, not email addresses, IPs, or other entities. It does not explicitly name alternatives or exclusion conditions, but the purpose sentence and sibling set make when-to-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 full burden of behavioral disclosure. It explains censoring behavior (replacement with asterisks), notes the use of a curated English profanity list, and lists the returned keys. It omits minor details like exact asterisk formatting, 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 well-structured and front-loaded with the core purpose. The behavioral note and Args/Returns sections are concise and every sentence adds value without filler.

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

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

The tool is simple and the description covers all essential aspects: input, behavior, and return keys. Since there is no output schema, listing the return keys is especially valuable. A minor note on the exact censoring format could be added, 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?

The schema only provides a title for 'text' with no description, so the 'Args' section adds necessary meaning and an example. The single parameter is clearly explained, compensating for the 0% schema description 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 a specific function: detecting and censoring profanity in text. It names the resource ('profanity in text') and the actions ('detect and censor'), which makes its purpose unmistakable and distinguishes it from the unrelated 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 implies when to use the tool: whenever English profanity must be flagged or censored in text. However, it does not explicitly contrast it with alternatives such as classify_text, nor does it 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 burden of behavioral disclosure and does substantial work: it lists supported algorithms, output formats, and the exact return dict keys including cost_usd. It does not explore edge cases or security caveats, but for a pure hash function the operational behavior is clearly 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 front-loaded with the core purpose, then uses compact labeled sections for arguments and return values. Each line adds necessary information and none is wasted.

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?

No output schema exists, but the description documents the return values and keys, all parameters, defaults, and supported algorithms. For a stateless utility, this is enough 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 coverage is 0%, and the description fully compensates by defining text, algorithm (with valid values and default), and encoding (with valid values and default). Every parameter is covered with meaning beyond the bare schema types.

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 object ('Hash text') and names it as a cryptographic hash function, immediately distinguishing it from sibling utilities like generate_password or generate_uuid. It enumerates the exact algorithm set, so an agent can tell this is the hash tool.

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

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

The description gives no guidance about when to choose this tool over sibling alternatives, nor any exclusions or prerequisites. It never names comparable tools such as encode_decode or jwt_decode, so the agent must infer usage from the name and first sentence.

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

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

With no annotations, the description carries the behavioral disclosure burden. It clearly states that generation uses Python's cryptographically secure secrets module and that the tool returns a password plus entropy estimate. This gives useful behavioral context beyond mere existence, though it does not explain the cost_usd field or possible side effects like API billing.

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 well-structured with a clear headline, a security note, a return summary, and a terse Args/Returns block. Every line adds value, and the most important information is front-loaded. There is no filler or repetition of schema defaults.

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 low-complexity generation tool, the description is nearly complete: it covers all parameters and returns keys. However, the output includes cost_usd without explanation, and there is no usage guidance or output schema to fill that gap. This is a minor but real incompleteness.

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

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

Schema description coverage is 0%, so the description must fully compensate. It documents all four parameters with meaningful semantics: length's range and default, symbols' example character set, numbers' digit scope, and uppercase's letter scope, each with defaults. This goes well beyond the bare schema property names.

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

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

The description opens with 'Generate a secure random password,' which is a specific verb plus resource and differentiates the tool from siblings like generate_uuid and generate_hash. The additional detail about returning an entropy estimate further clarifies what makes this tool 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?

No explicit when-to-use or when-not-to-use guidance is provided. The description does not mention alternatives such as generate_uuid or generate_hash, nor does it specify scenarios where this tool is preferred over check_password_breach or other password-related tools. Usage context is only implied by the tool's name and 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 disclosure burden, and it does well: it states the output is a base64-encoded PNG plus an HTML data URI and enumerates the exact return keys (image, data_uri, qr_version, modules, cost_usd). Minor gaps — cost_usd hints at billing but is never explained, and error/capacity behavior (e.g., QR content-length limits) is not mentioned — keep this short of a 5.

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 docstring-style layout is front-loaded (purpose first), then content scope, Args, and Returns — scannable and well organized. It loses a point for minor redundancy: the opening paragraph already mentions the base64 PNG and data-URI outputs, and the Returns section repeats those two keys.

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 low-complexity tool (3 params, 1 required, no enums, no output schema), the description covers purpose, every parameter, and the full return shape, so an agent can invoke it successfully. The remaining gaps — error behavior for oversized content and the meaning/billing implication of cost_usd — are not covered.

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

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

Schema description coverage is 0%, and the Args section compensates fully: each parameter gets a plain-language meaning ('The text or URL to encode', 'Pixel size of each QR module', 'Quiet-zone border width in modules'), a numeric range (1–20, 1–10), and explicit defaults that match the schema. This goes well beyond the bare typed integers in the schema.

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

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

The description states a specific verb and resource ('Generate a QR code') plus the input scope ('from any text or URL'). It is immediately distinguishable from the many sibling generate_* tools (generate_uuid, generate_hash, generate_password), none of which overlap QR functionality, and the supported-content list further sharpens exactly what the tool produces.

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

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

The 'Works for URLs, plain text, vCards, WiFi credentials, payment links, etc.' list gives implied context about when to use the tool. However, there is no explicit when-to-use/when-not-to-use guidance, no exclusions, and no alternatives mentioned. Since no sibling tool overlaps QR generation, the missing routing is low-cost, but the guidance that exists is implied rather than 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 of behavioral disclosure. It concretely explains normalization, punctuation removal, whitespace collapsing, lowercasing, and the separator options, and it discloses the return dict keys. It does not mention edge cases like empty input or max_length truncation semantics, but the core behavior is well covered.

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

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

The description is front-loaded with the purpose, followed by compact transformation details and a structured Args/Returns section. Every sentence adds information, and the example is illustrative without being 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?

For a low-complexity utility with no output schema, the description is complete enough: it states inputs, transformations, parameter semantics, and the return format. The agent can confidently call the tool with correct arguments and know what the response will contain, including the cost field.

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

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

Schema description coverage is 0%, so the description must compensate. It adds useful meaning beyond the schema: a concrete text example, allowed separator values ('-', '_', '.'), and clarification that max_length is optional. It does not fully specify how max_length truncates the slug, but each parameter is meaningfully described.

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: 'Generate a URL-safe slug from any text.' It further distinguishes the tool by listing exact transformation behaviors (Unicode normalization, punctuation removal, whitespace collapsing, lowercasing), leaving 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 phrase 'from any text' gives a clear and general usage context, and the example input 'Hello World! Café & More' demonstrates representative inputs. It does not explicitly name alternatives or exclusions, but none of the sibling tools perform slugification, so this is a minor gap.

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 does disclose meaningful behavior: version semantics, the 100-UUID limit, and the exact return keys (uuid, uuids, version, count, cost_usd). However, it does not describe side effects, billing implications of cost_usd, or whether this is a safe read-only operation, leaving some behavioral 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 front-loaded with the core purpose, then gives a compact 'Args' and 'Returns' block. Every sentence earns its place: the version explainer and the limit note are both necessary, and there is no filler or repetition.

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

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

For a simple tool with only two optional parameters, the description is complete. It provides parameter ranges, defaults, return structure, and the key limit. The mention of cost_usd is not explained in depth, but it does not block an agent from selecting and invoking the tool correctly. No output schema exists, but the description compensates with the return dictionary layout.

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

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

Schema description coverage is 0%, so the description must compensate, and it does fully. It explains that version is 1 or 4 with default 4, and count is 1–100 with default 1. It also gives the practical meaning of each version (MAC+timestamp vs random). This goes well beyond the bare integer types in the input 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 'Generate one or more UUIDs' with a specific verb and resource, and clarifies the two supported versions (v1 and v4). This clearly distinguishes it from sibling tools like validate_uuid, generate_hash, or generate_password, so an agent can immediately tell 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 explains when to use this tool implicitly: if you need UUIDs, choose version 1 or 4 and a count. It also gives guidance on version selection by explaining that v1 uses MAC address + timestamp and v4 uses random. However, it does not explicitly mention when not to use it or point to alternatives such as validate_uuid for validation tasks, leaving the choice partially to inference.

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

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

With no annotations, the description carries full behavioral burden, and it delivers: it discloses 'Pure compute, no outbound network,' that 'The original token is never logged,' which algorithms are verified, and precisely how signature_verified will be set. This goes well beyond the schema.

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

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

The description is compact, front-loaded, and well-structured with Args and Returns sections. Every sentence adds useful information, and there is minimal 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?

Given two simple parameters, no annotations, and no output schema, the description covers both parameters and explicitly lists all return keys. An agent has everything needed to call the tool correctly and interpret its result.

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

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

Schema description coverage is 0%, so the description must compensate, and it does thoroughly. It defines token as a 'Full JWT string (three dot-separated base64url segments)' and explains the exact semantic effect of providing optional secret. This adds real meaning beyond the bare schema properties.

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: 'Decode a JWT and (optionally) verify the HMAC signature.' This clearly differentiates the tool from other validation/enrichment siblings by naming the exact operation and the optional verification mode.

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 when to use it: whenever a JWT needs decoding or signature verification. It also clarifies the conditional behavior with and without a secret, which is strong usage context, though it does not explicitly name alternatives 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, the description carries the burden of behavioral disclosure and does so well: it notes that the tool is 'live,' 'unauthenticated,' and 'not billed' despite being a billed-utility catalog. It also reveals the return payload shape and that the catalog may include routes with outbound_io flags, so the agent understands side effects and access requirements.

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, front-loaded with the most important trait (unauthenticated, not billed), and organized into usage, args, and returns. Every line adds value; 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 simple optional-boolean catalog tool with no output schema, the description is complete: it explains why to call it, what the parameter does, and what the return payload contains. It even provides the next-step guidance to call a named tool or call_enrichr(path, body), making the full workflow clear.

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

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

Schema coverage is 0% and the parameter has only a title, so the description must fully explain semantics. It does: 'outbound_io_only' is described with its exact filtering behavior and a list of example external systems (VAT, HIBP, IP geo, MX, currency, postal). This goes well beyond the bare boolean schema.

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

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

The description states a specific action ('list' the live billed-utility catalog), identifies the resource (routes, prices, rate limits, outbound_io flags), and clarifies its role as a discovery entry point. It also distinguishes itself from siblings by explaining that after catalog discovery you call a named tool or call_enrichr(path, body).

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 explicitly tells the agent to use this tool to discover routes and metadata before invoking other tools, giving clear context. It does not enumerate when-not-to-use cases or directly compare with alternative discovery tools, but the guidance is sufficient for a catalog 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 the full disclosure burden. It does this well by enumerating the full return dict including the 'found' key (implying graceful miss handling) and 'cost_usd' (signaling the tool has a monetary cost). It omits error behavior and rate limits, but for a single-query lookup this is a solid 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 front-loaded with the purpose, then uses compact examples to convey format flexibility, then a tight Args/Returns breakdown. Every sentence earns its place; the example list is the most economical way to communicate the multiple accepted formats. 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 single-parameter lookup tool with no output schema, the description is nearly complete: input format, reverse behavior, and the full returned dict including cost are all specified. The only gap is explicit error-handling behavior, which the 'found' key mitigates. Minor omission given 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?

Schema description coverage is 0%, so the description must fully compensate — and it does. It defines the query parameter as 'File extension, filename, or MIME type string' and illustrates the acceptable formats with examples in both directions. Auto-detection between forward and reverse is made explicit, leaving no ambiguity about input.

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

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

Description states a specific verb and resource ('Look up a MIME type by file extension or filename') and adds a reverse-lookup mode. Concrete input examples (png, .png, photo.png, archive.tar.gz, image/png) make the tool's scope unambiguous. No sibling tool overlaps in function, so differentiation is inherent but the description still pins the purpose precisely.

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 forward/reverse distinction with worked examples tells an agent exactly what to pass and what to expect back. There is no explicit 'when not to use' clause, but no sibling tool handles MIME types, so alternatives are not relevant. The guidance is implicit-but-strong through examples rather than explicit exclusion language.

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 mentions the external service (Zippopotam.us) and lists return keys including 'valid' and 'cost_usd', which hints at potential costs. It does not explicitly state that the operation is read-only or describe error behavior, but the 'valid' flag and read-only intent ('look up') cover this adequately.

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 well-structured with clear sections for args and returns. Every sentence adds value—purpose, scope, parameter details, and return schema are all covered without verbose fluff. It is appropriately sized for the tool's complexity.

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

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

Given the simple tool (2 params, no output schema), the description is complete. It explains what data is returned and the expected output keys. No critical information is missing for an agent to use this tool correctly.

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

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

Schema coverage is 0%, so the description must fully explain parameters. It does: postal_code is described with examples and country is described with the ISO 3166-1 alpha-2 format and a default of US. This goes beyond the bare schema definition, providing the agent with enough detail to invoke correctly.

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

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

The description states an explicit action (look up), a clear resource (postal code), and the expected results (city, state, coordinates). It also distinguishes itself from sibling tools by focusing on postal codes and mentioning the data source (Zippopotam.us), which is unique 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 purpose is self-evident and no sibling tool overlaps with this function, so an implicit usage context is clear. However, it does not explicitly state when not to use it or mention any alternatives, leaving some room for inference.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the full return contract, including valid, is_dst, and cost_usd, and notes it uses Python's stdlib zoneinfo, implying no network/auth dependency. It does not explain invalid-timezone behavior explicitly, but the valid key signals it.

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 organized into Intro, Args, and Returns sections, which is easy to parse. There is mild redundancy between the opening sentence and the Returns block, but no wasteful 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?

For a simple single-parameter lookup with no output schema and no annotations, this description is complete: it documents the parameter format with examples, names the implementation, and enumerates the exact return keys. Nothing needed for correct invocation 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 0% and the schema only labels the parameter 'Timezone'. The description compensates fully with 'timezone: IANA timezone name' and concrete examples like America/New_York and Europe/London, giving the agent exactly what it needs to format the argument.

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

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

States a specific verb and resource: 'Look up timezone information by IANA timezone name.' The returned fields (UTC offset, DST status, abbreviation, local/UTC time) make it clearly distinct from the sibling convert_timezone, which would convert between zones rather than describe one.

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: when an agent needs current timezone metadata for an IANA name. It does not explicitly name alternatives or exclusions, but the return-field listing makes 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 provided, the description carries the burden of behavioral disclosure. It does specify the full return key set and confirms this is a pure parsing operation, but it does not explain behavior on invalid URLs, edge cases, or what 'cost_usd' implies. This is adequate but not richly 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 efficiently structured with a one-sentence summary, a bullet-style component list, and Args/Returns sections. Every part adds useful information and nothing is redundant.

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 parse utility with no output schema, the description provides the parameter meaning, an example, and a complete list of return keys. Minor omissions like error handling and cost semantics prevent a perfect score, but the tool is simple enough that the description is largely 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 input schema gives zero description coverage, so the description must compensate. It provides a clear purpose for the 'url' parameter and a concrete example URL, which is enough for an agent to understand the expected 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 states a specific verb and resource: 'Parse a URL into its components,' and then enumerates exactly which components are extracted. This clearly distinguishes it from sibling tools like parse_user_agent, which parses user-agent strings instead of URLs.

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

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

The intended use is strongly implied by the tool name and summary, but there is no explicit when-to-use or when-not-to-use guidance, and no alternatives are mentioned. An agent can infer usage, but the description does not actively steer the decision.

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

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

No annotations are provided, so the description carries the full burden. It mentions the return structure (keys) and bot detection, which adds some transparency. However, it doesn't disclose whether the operation is read-only, whether it makes network calls, or any error/edge-case behavior. The mention of 'cost_usd' hints at potential billing but isn't explained.

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, well-structured with a summary and Args/Returns sections. Every line earns its place, and the most important information (what it does) is front-loaded. No unnecessary 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 single-parameter tool with no output schema, the description covers the return keys, which is good. However, it omits error conditions, potential null returns, or any caveats about the cost_usd field. Given the lack of annotations, it should also clarify whether this is a safe read-only operation. These gaps make it less complete than it could be.

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 the user_agent parameter (0% coverage), so the description must compensate. It explicitly says 'The full User-Agent header value', which clarifies what format is expected. This is helpful and goes beyond the schema's type-only declaration.

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

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

The description clearly states the action (parse a User-Agent string), the target (browser, OS, device), and specific capabilities (detects 7 browsers, 9 OS variants, device type, and 17+ bots). This is a specific verb+resource and distinguishes it from sibling tools like parse_url or convert_units.

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

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

No guidance on when to use this tool vs alternatives. It doesn't mention when not to use it, prerequisites, or mention any other tool as an alternative. The description assumes the user knows they need to parse a UA string, but doesn't help an agent decide between this and other 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?

With no annotations provided, the description carries the full behavioral burden. It discloses the destructive effect (old key is deactivated immediately), the continuity of billing on the same subscription, and the critical constraint that the returned api_key cannot be retrieved later. This is strong behavioral context for a mutation operation, though auth requirements are not mentioned.

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 well-structured: it states the action first, then the behavioral consequences, then the user instructions, and finally the return shape. Every sentence adds necessary operational value 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 zero-parameter, no-output-schema tool, the description is complete. It names the return keys, tells the agent how to present the result, and warns about the one-shot retrieval limitation. There are no missing details an agent would need to call this 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 tool has zero parameters, so the schema provides nothing to interpret. The description appropriately explains the return value and the post-call handling of the api_key, which is the only semantic information an agent needs here.

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: "Rotate the current Enrichr API key." This unambiguously identifies the action and object, and it is clearly distinct from sibling tools like call_enrichr, account_usage, and billing_portal, which serve unrelated account or enrichment 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 phrase "Rotate the current Enrichr API key" implies when to use it, and the behavior around deactivation clarifies the effect. However, there is no explicit guidance about when to prefer this tool over alternatives, nor any stated exclusions or prerequisites for using 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 that the raw key is returned only once, that verification via email is required for free monthly allowance and lost-key recovery, and that unverified keys do not receive the free tier. It also describes the return keys, providing useful behavioral context beyond a basic creation action.

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, front-loaded with the core purpose, and has clearly labeled Args and Returns sections. Every sentence carries important information (return-once behavior, verification requirement, free tier condition) without unnecessary 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 tool's complexity (signup with verification, free tier, lost-key recovery) and lack of output schema or annotations, the description covers the critical behaviors and return values. It does not mention error cases like duplicate email, but the description is otherwise complete enough for an agent to understand the signup flow.

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

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

The schema has 0% description coverage, so the description must compensate. It only says 'email: The user's email address', which adds little beyond the schema's title 'Email'. No format, constraints, or behavioral implications of the email are explained, despite the description later referencing email verification.

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 'Create an Enrichr API key' – a specific verb and resource. This clearly distinguishes it from siblings like rotate_api_key, which handles key rotation rather than initial creation. The subsequent details about verification and return keys reinforce 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 implies usage for signing up and obtaining a new API key, and explains the verification step and free tier. However, it does not explicitly state when to use this tool vs alternatives like rotate_api_key or account_usage, nor does it mention when not to use it. The context is sufficient but not explicit about 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 behavioral burden. It discloses that credits are only applied after the Stripe webhook fires, that a human must open the URL, and that the tool returns a specific error when purchases are disabled. This goes well beyond a minimal description.

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

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

The description is reasonably short and front-loaded, but it repeats return information: it first says 'Returns a hosted Checkout URL' and later repeats 'Returns: dict with keys: url.' Merging these would make it tighter.

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 zero-parameter tool with no output schema and no annotations, the description covers the essential invocation context: what the tool starts, what is returned, what the human must do, the asynchronous credit behavior, and the disabled-purchases error case. It is sufficiently complete for an agent to use 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 tool has zero parameters, so there is no parameter semantics burden. The description reinforces this by noting the top-up is 'server-configured,' meaning the agent should not expect or supply any arguments.

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

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

The description states a specific action: 'Open Stripe Checkout for the server-configured prepaid top-up.' The verb and resource are clear, and the purpose is distinct from siblings like billing_portal, though it does not explicitly name the distinction.

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

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

The intended use is implied by 'prepaid top-up,' and the description notes the human must open the returned URL. However, it does not explicitly explain when to use this tool versus alternatives such as billing_portal, nor does it provide when-not-to-use conditions.

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

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

With no annotations, the description must carry the full burden, and it does disclose useful behavior: it always returns all three formats and a WCAG-luminance-based dark/light indicator, and lists the output dict keys. However, it does not state what happens for invalid colors (e.g., whether `valid` is just false or whether an error is thrown), which is a salient behavioral gap for a validation 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 tight and well-structured: a two-sentence summary, followed by compact Args and Returns blocks. Every line adds either input format knowledge or output contract knowledge, 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?

Given there is no output schema, the description properly documents the return shape and normalization behavior. The only meaningful omission is invalid-input behavior, which prevents a perfect completeness score for a tool whose primary purpose is validation.

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 says `color` is a string, so the description provides essentially all semantic meaning. It spells out supported formats with concrete examples (e.g., #FF5733, #F53, rgb(255,87,51), hsl(14, 100%, 60%)) and confirms the input is 'a color string in any supported format,' fully compensating for 0% 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 opens with a precise verb-resource pair: 'Validate a color and convert it between hex, rgb, and hsl formats.' It then enumerates the accepted input formats, making it unmistakably distinct from sibling validate_* and conversion 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 clearly defines the valid input domain (hex, shorthand hex, rgb, rgba, hsl, hsla) and tells the agent what will be returned, making the conditions for use clear. It does not explicitly name alternatives, but no sibling tool targets color, so exclusions are 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?

The description discloses a key behavioral trait: the full card number is never logged or stored, only a masked version is returned. This is valuable privacy/security context beyond what annotations provide (none). It also explains the return keys, which adds transparency about what the tool does.

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 well-structured with a short summary, a behavioral note, an Args section, and a Returns section. It's slightly longer than necessary but every sentence adds value. The privacy note is front-loaded after the summary.

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 no output schema, the description covers the input format, the validation logic, the privacy behavior, and the return keys. It doesn't describe error handling or edge cases (e.g., empty string, invalid characters), but the core information an agent needs 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?

Schema coverage is 0%, so the description must compensate. It does: it explains the 'number' parameter accepts spaces or dashes and gives an example. It doesn't specify maximum length or whether non-string types are accepted, but for a single-param tool this is adequate.

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 a credit card number, performs Luhn checksum verification, and detects the card network. It names specific networks and distinguishes itself from sibling validation tools (validate_vat, validate_iban, validate_domain) by focusing on credit cards.

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 this tool (when you need to validate a credit card number) and provides input format examples. It doesn't explicitly state when not to use it or name alternatives, but the sibling list makes the context 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?

With no annotations, the description carries the full disclosure burden. It declares the DNS checks performed (A record, MX), the negative scope ('not mailbox/SMTP'), and the full return dict including is_disposable and cost_usd. It does not mention network latency or whether the operation is billable, but the cost_usd key at least surfaces cost.

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 purpose sentence, a compact Args/Returns block, and no filler. The critical exclusion is front-loaded, and every clause adds 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 1-parameter, no-output-schema tool, the description covers what it validates, what it ignores, the exact input shape, and every return key. An agent can confidently invoke it and interpret the result without additional context.

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

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

The schema only says 'domain: string' with zero coverage, so the description must compensate. It does so excellently by defining accepted forms ('Hostname or URL'), providing examples ('example.com' or 'https://example.com/path'), and implying URL normalization – exactly the guidance an agent needs.

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 'Validate a domain: format, DNS A record, and MX' – a specific verb and resource plus the exact checks performed. The parenthetical '(not mailbox/SMTP)' proactively disambiguates from email-validation siblings like enrich_email and makes the boundary explicit.

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 clearly states the validation scope and explicitly rules out mailbox/SMTP, signaling that this tool is for domain-level checks rather than email deliverability. It doesn't name alternatives like validate_domain_batch, but the single-domain argument and sibling name make that choice inferable.

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. It discloses billing per item, the 100-domain cap, cost_usd and call_count_this_month in the response, and the error return shape. It could add more about partial failures or rate limiting, but the key behaviors are covered.

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

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

The description is compact and well-organized: use case, caveat, argument definition, and return shape. Every line adds information, and the most important constraints are 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?

Given one parameter, no output schema, and no annotations, the description covers invocation and response keys well. The 'data' field inside results is not expanded, but referencing 'same checks as validate_domain' is enough for an agent to know what it contains.

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

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

Schema coverage is 0%, so the description must explain the domains parameter. It does so effectively by specifying the 1–100 count and the accepted formats (hostnames or URLs), adding meaning the schema's 'array of strings' does not provide.

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

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

States a precise operation: validate up to 100 domains in a single call. It explicitly relates to sibling validate_domain and excludes mailbox verification, making the tool's scope and identity clear.

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

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

The description gives clear context: batch validation of up to 100 domains, same checks as validate_domain, and explicitly not mailbox verification. It does not explicitly say 'use validate_domain for a single domain', but the batch framing makes that usage distinction 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 provided, the description carries the full burden, and it delivers: it discloses the 77-country scope, the ISO 7064 MOD-97-10 checksum, the pure-math/no-external-API behavior, and the exact return keys. This gives an agent a reliable picture of what will happen when invoked.

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 well-structured with a one-sentence purpose statement, a short behavioral note, an Args section, and a Returns section. Every sentence adds value, and the most important information 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?

Given the simple single-parameter schema and no output schema, the description is complete: it explains the input format, what validation is performed, and what the response contains. An agent has everything needed to select and invoke this tool correctly.

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

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

The schema provides zero description coverage, but the description fully compensates by documenting the single iban parameter, including the acceptable format ('optional spaces') and a concrete example. Since there is only one parameter, this is complete 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 opens with a clear verb and resource: 'Validate an IBAN (International Bank Account Number).' It then states exactly what validation covers (format, length, checksum) and stands apart from sibling validators like validate_vat and validate_credit_card by naming IBAN explicitly.

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 call the tool: whenever an IBAN needs syntactic and checksum validation. It also adds a differentiating trait, 'No external API — pure math,' which signals suitability for offline or no-fee validation. It does not explicitly list alternatives, but the resource type makes 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 full burden, and it delivers by listing exact response keys (valid, root_type, key_count, item_count, depth, formatted, minified), the error keys (error, line, column), and cost_usd. This goes well beyond the sparse schema and leaves little guesswork about output or failure 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 front-loads the main action in one sentence, then uses compact structured sections for Args and Returns. Every line carries useful information with no filler or repetition.

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

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

For a one-parameter tool with no output schema, the description fully specifies input, output contract, error behavior, and even a cost field. No additional context is needed for an agent to call this tool correctly.

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

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

The schema only says 'json_string' is a required string with no description (0% coverage). The description compensates by stating it is the raw JSON string and provides a concrete example, so an agent knows exactly what value to pass.

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 first sentence names a concrete action ('Validate, format, and analyze') and a specific resource ('a JSON string'). It distinguishes this tool from unrelated sibling validators because it is the only one focused on JSON parsing, and the detailed output list makes its scope 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 establishes clear context: use this tool when a caller needs JSON validation, formatting, or structural analysis. It does not explicitly name alternatives or phrase when-not-to-use conditions, but no listed sibling targets JSON, so the intended use case is easy to identify.

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, but the description carries the burden well: it discloses compilation with optional flags, the match result structure (start/end, capture groups, named groups), and the full return dict including valid_pattern and cost_usd. It doesn't explicitly state invalid-pattern handling beyond the valid_pattern key, but this is a modest 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 summary sentence front-loads the purpose, followed by a compact Args block and a Returns list. Each section earns its place, and the flag/max_matches details are concise rather than 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?

With no output schema, the description includes the complete return contract (keys and match structure) plus all parameter constraints. Minor omissions like exact invalid-pattern error behavior prevent a perfect score, but the tool is fully callable from this description alone.

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

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

Schema coverage is 0%, so the description provides all parameter semantics: pattern with an example, test_string purpose, flags with allowed letters and meanings, and max_matches with range and default. This fully compensates for the sparse schema.

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

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

The description states a specific verb ('Test') and resource ('a regex pattern against a string'), and details what it returns (all matches with positions, capture groups, named groups). This clearly differentiates it from sibling validation tools like validate_domain or validate_uuid, which target different resources.

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 establishes the tool's context: testing a regex pattern against a string and returning matches. It doesn't explicitly discuss alternatives or exclusions, but the purpose is specific enough that an agent can route to it over the validation siblings without 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?

No annotations are provided, so the description carries the full burden. It discloses the exact validation behavior, the version detection logic (v1/v3/v4/v5), and enumerates all return keys including the surprising cost_usd field. This is comprehensive for a simple validation utility, though it could mention error behavior more explicitly.

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 uses a compact docstring structure with purpose, args, and returns. Every line adds useful information—the format check, version detection, example input, and return key list—with no filler or unnecessary repetition.

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

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

Despite having no output schema or annotations, the description is sufficient for an agent to invoke the tool correctly and interpret results. It covers input format, validation behavior, and all return fields; even the unexpected cost_usd key is named, making the tool's behavior predictable.

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 declares a required string property named uuid with no description (0% coverage). The description compensates by explaining the parameter is a UUID string and providing a concrete example, which adds meaning the schema lacks.

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 action and resource: 'Validate a UUID string and extract its metadata.' It then pinpoints the standard UUID format and version detection, which clearly differentiates it from sibling validation tools like validate_domain or validate_vat.

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 a UUID needs validation or metadata extraction—but it does not explicitly state when not to use it, mention prerequisites, or name alternatives. The scope is clear, but exclusionary guidance is absent.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It explains the two-step behavior: format validation against country-specific patterns and a live VIES lookup, and it lists the return keys including cost_usd. It does not cover failure modes or VIES unavailability, but the core behavior is 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 compact and front-loaded with a one-sentence summary, followed by precise behavioral details and a brief Args/Returns section. Every sentence earns its place 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 single-parameter tool with no annotations and no output schema, the description covers the input format, validation behavior, and return contract, including the cost_usd field. It could be more explicit about live-service caveats or error behavior, but the essential information needed to call 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 input schema provides only a string type with no description, so the description must compensate. It does so by defining the expected format ('VAT number with country prefix') and giving concrete examples such as 'DE123456789' and 'FR12345678901'. This is enough for an agent to format the parameter correctly, though edge cases like case or separators are not covered.

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 'Validate a European VAT number' and gives a specific verb plus resource. It further distinguishes itself from sibling validators by describing the country-specific format check and live VIES database verification, so there is no ambiguity against validate_domain, validate_iban, or other 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 scopes usage to European VAT numbers with country prefixes, which clearly implies when this tool is appropriate. However, it does not explicitly mention alternatives, exclusions, or when not to use it; the guidance is inferred rather than 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 provided, the description carries the full burden of behavioral disclosure. It states the operation is HMAC signing, enumerates configurable algorithm/encoding/template behavior, and lists the exact return keys including signing_string. It also adds a practical accuracy note about using exact bytes for the body.

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 well-structured: an intro sentence, a brief usage note, then an Args/Returns breakdown. Every sentence adds value, and the most important behavioral detail (HMAC signing) 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 tool with no output schema and no annotations, this description is complete: it documents every parameter, all defaults, return keys, and practical usage scenarios. An agent has enough information to invoke the tool correctly and interpret its result.

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

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

Schema description coverage is 0%, and the description fully compensates by documenting all six parameters: body, secret, algorithm, encoding, timestamp, and template. It adds meaning beyond the schema with default values, allowed algorithm/encoding choices, template semantics, and the Stripe format example.

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: 'Produce an HMAC signature for a webhook body.' It clarifies the exact artifact being generated and distinguishes it from related utilities like webhook_verify, which would consume rather than produce signatures. The Stripe-style example further anchors 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 gives clear contexts for use: testing webhook receivers, generating Stripe-style signatures, and signing outbound webhooks. It does not explicitly state when not to use this tool or name alternatives like generate_hash, but the provided use cases are sufficient for an agent to decide.

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

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

With no annotations, the description carries the full behavioral burden and addresses it well: it names the constant-time comparison, the byte-equal condition for matches=True, and the exact return-key set. It could add error behavior or clarify the 'valid' key, but the core verification semantics are 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?

Compact and front-loaded: the first sentence states the action, the second links to the sibling and identifies the difference, and the third enumerates the return contract. No filler; every line 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 more complex than a simple filter: seven parameters, no annotations, and no output schema. The description gives good behavior and output shape, but leaves parameter semantics largely to the schema and does not define how timestamp or template interact with verification.

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

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

Schema description coverage is 0%, so the description needed to explain the seven parameters; it only names signature and points at webhook_sign for the rest. Body, secret, encoding, template, algorithm, and timestamp semantics are largely left to the schema's titles and defaults.

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?

Opens with a specific verb and resource, 'Constant-time verify an HMAC webhook signature,' and explicitly contrasts with the sibling webhook_sign by noting it shares parameters plus the signature. This lets an agent distinguish verify from sign without inspecting the schema.

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

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

The 'Same parameters as webhook_sign plus the candidate signature' line positions it relative to its natural sibling, and the verify/sign pairing makes the intended use clear. It does not spell out when not to use this tool, but the constant-time verification context is enough to route an agent correctly.

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