icme-preflight

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

With no annotations, the description carries full burden and excels: it reveals internal operation (SMT solver not LLM), return semantics (SAT/UNSAT with extracted values and ZK proof), a strong security claim (cannot be jailbroken), and cost. This exceeds what structured metadata would provide and gives the agent a solid behavioral model.

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

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

The description is compact yet information-dense, leading with purpose, then mechanism, outputs, proof, cost, key requirement, and a practical tip. Every sentence contributes value, and the structure is front-loaded for quick scanning.

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 no output schema, the description explains the return format (SAT/UNSAT with extracted values and ZK proof) and prerequisites (api_key, cost). It also covers security and usage tips, making the tool self-contained for an agent to invoke correctly. Missing error cases are minor given the clarity.

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

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

Schema coverage is 100% so baseline is 3, but the description adds meaningful parameter guidance via the tip about ending the action with an explicit compliance claim to improve extraction. It also reinforces the api_key requirement, though that is already 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 opens with a specific verb ('Enforce a guardrail') and resource ('agent action against a compiled policy'), clearly distinguishing this from LLM-based checks by emphasizing formal verification via an SMT solver. It also states the output (SAT/UNSAT) which clarifies its role among 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 gives clear context on when to use the tool (for policy verification with formal guarantees) and adds practical guidance such as the 1 credit cost, requirement for api_key, and the tip about ending actions with an explicit claim. However, it does not explicitly discuss alternatives or exclusion criteria compared to siblings like check_action_paid.

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 discloses key behaviors: cost ($0.10 USDC on Base), authentication (none needed), and output (SAT/UNSAT with extracted values and optional ZK proof). It does not mention side effects or rate limits, but for a verification tool this is reasonable transparency.

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

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

Two sentences, front-loaded with the core purpose, and no wasted words. It efficiently conveys payment model, auth requirements, and return format.

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

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

The description covers purpose, payment, auth, and output, and references check_action for core behavior. It does not detail the optional ZK proof or potential limits, but for a 2-parameter tool with no output schema, it is largely complete.

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

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

Schema coverage is 100% and both parameters have clear descriptions. The description adds no parameter-specific details beyond the schema, though it does mention the output format (extracted values) which relates to the action parameter. Baseline 3 is appropriate.

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

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

The description clearly states this tool performs formal verification of actions, matching check_action but with a pay-per-call model. It explicitly names the sibling alternative and adds the payment distinction, making the tool's purpose unambiguous.

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

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

The description says 'instead of using credits' and 'No API key or account needed', which implies using this tool when you lack credits or an account. It references check_action as an alternative, but does not explicitly state 'use check_action if you have credits' – though the contrast is clear.

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

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

With no annotations provided, the description carries the full burden. It discloses free access ('FREE — no account needed'), the underlying method (Z3 SAT solver), and the exact return values (CONSISTENT, CONTRADICTION, or UNKNOWN with extracted claims). This is highly 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 four sentences, front-loaded with the core purpose, and every sentence adds value. It is appropriately sized and contains no redundant information.

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

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

Given the moderate complexity, no output schema, and no annotations, the description provides sufficient context: it explains the purpose, method, return behavior, and access requirements. The agent has enough information to decide when and how to invoke the tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds little beyond what the schema already provides for parameters; it only hints at return behavior with 'with the extracted claims.' It does not elaborate on parameter meanings or formats beyond the schema.

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

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

The description clearly states the tool's purpose: 'Catch contradictions in reasoning before acting on it.' It specifies the resource (reasoning) and the action (catch contradictions). It also distinguishes itself from sibling check_* tools by focusing on formal verification with a Z3 SAT solver, not on actions or relevance.

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 before acting ('before acting on it') and clarifies that it is formal verification, not an LLM second-guessing itself. It doesn't explicitly list alternatives or when not to use it, but the context across sibling tools (check_action, check_relevance) makes the intended use clear.

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

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

Since no annotations are provided, the description carries the full burden. It discloses that no credits are charged, what is returned ('relevance score and which variables matched'), and the meaning of should_check. It does not mention potential errors or rate limits, 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 four sentences, each adding value: purpose, return values, conditional guidance on next steps, and cost/auth note. It is front-loaded with the core function and avoids redundancy with the 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?

Given the lack of output schema and annotations, the description compensates well by explaining the return values and decision logic. However, it does not specify the response format beyond the mentioned fields, so it is not fully complete but sufficient for the tool's scope.

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

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

The input schema covers 100% of parameters with descriptions, including the threshold's default and effect. The description itself adds little beyond the schema, only mentioning the api_key requirement, which is already in the schema. This meets the baseline but does not exceed it.

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

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

The description clearly states the tool's function: 'Free relevance screen — checks whether an action touches any of your policy variables before running a paid check.' It uses a specific verb and resource, and distinguishes it from siblings like check_action and check_action_paid by positioning it as a pre-screening step.

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?

Explicit guidance is provided: use this tool before a paid check, and the description gives clear next steps: 'If should_check is true, run check_action. If false, the action is unrelated to your policy — skip the paid check.' It also notes 'No credits charged,' reinforcing when this should be used.

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 key behavioral details: the API key is shown only once (must be saved), starting credits are granted immediately, and the payment amount. It does not mention error cases (e.g., duplicate username), but the critical one-time key behavior is highlighted.

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

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

The description is concise and well-structured: it states the action, payment, return values, a critical warning, and the alternative in just four sentences. Every sentence earns its place with no fluff.

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

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

Given the tool's simplicity (one parameter, no output schema), the description covers the essential context: purpose, payment, result, and key handling. It could optionally address failure scenarios, but overall it is sufficiently complete for an agent to use the tool correctly.

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

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

The input schema has one parameter (username) with a complete description (100% coverage). The description does not add extra semantics about the parameter, but the schema already provides the format and constraints. Baseline 3 is appropriate.

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

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

The description clearly states the tool's function: creating an ICME Preflight account with a specific payment method (x402 USDC, $5.00). It explicitly differentiates from the credit-card alternative (create_account_card), so an agent can easily identify the correct 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 explicit usage context: use this tool when paying via USDC, and use create_account_card instead when paying by credit card. This provides clear when-to-use and alternative guidance.

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

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

No annotations are provided, so the description carries the full burden. It discloses the $5 Stripe payment, the return of a checkout_url, and the subsequent need to call poll_session with session_id. It does not mention potential failure modes or whether session_id is returned, but the core multi-step behavior is clearly 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?

Two concise, front-loaded sentences cover the action, payment, and next steps. No filler or redundancy; every sentence adds necessary information.

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

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

The description explains the return value (checkout_url) and the follow-up call to poll_session. However, it does not explicitly state that session_id is also returned in the response, which is a minor gap. Still, given the single parameter and existing flow, it is largely complete.

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

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

Schema description coverage is 100% for the single 'username' parameter, and its description already covers constraints. The tool description adds no additional parameter context beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description specifies a clear action (create), a specific resource (ICME Preflight account with a credit card), and includes payment details ($5.00 via Stripe). It distinguishes from sibling 'create_account' by explicitly mentioning the credit card payment requirement.

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

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

The description provides a clear workflow: create the account, pay via checkout_url, then poll_session. It does not explicitly contrast with 'create_account' or state when not to use this tool, but the payment context makes the intended use unambiguous.

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. It uses 'Review' and 'Shows' to imply a read-only operation and mentions the compiled policy prerequisite, but does not explicitly state whether it has side effects, consumes credits, or how it handles invalid policy IDs.

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

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

The description is short and front-loaded with the purpose. The final sentence 'Requires api_key' is redundant with the schema, representing minor waste, but overall structure is efficient.

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

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

For a simple 2-parameter read tool with no output schema, the description provides enough context: reviewing scenarios before deployment, with pass/fail examples. It does not explicitly differentiate from run_tests but the verb 'review' makes it 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?

The schema already describes both parameters fully (api_key and policy_id) with 100% coverage, so the description adds no additional meaning. Baseline of 3 is appropriate.

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

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

The description clearly states the tool reviews auto-generated test scenarios for a compiled policy, with a specific verb-resource pair. It also explains that it shows pass/fail example actions, distinguishing it from sibling tools like run_tests.

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 specifies the context 'before deploying' the policy, which is clear guidance on when to use it. However, it does not explicitly mention alternatives or exclusions among 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, the description carries the full burden and does a good job: it discloses the costs (300 credits), required authentication (api_key), and return values (policy_id and test scenarios). It also explains the formal solver mechanism. It stops short of describing failure modes or side effects like whether an existing policy is overwritten, but the provided details are substantive and non-obvious.

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

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

The description is three sentences, each carrying meaningful information: what it does, why it's different, and what you get/cost. It is front-loaded with the core purpose and avoids filler. No word 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?

For a creation tool with two params and no output schema, the description covers input, process, output, cost, and auth. It lacks guidance on how to use the returned policy_id with sibling tools like check_action, but this is not strictly required. The description is complete enough for an agent to invoke correctly.

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

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

Schema coverage is 100% — both 'policy' and 'api_key' have descriptions that clearly explain their meaning and format. The tool description adds only a few redundant details (e.g., that api_key is required), so it does not significantly enhance what the schema already provides. Baseline 3 is appropriate.

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

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

The description clearly states the tool's function: converting plain-English policy text into a formal, solver-enforced guardrail. The verb 'Turn' plus the resource ('plain-English policy into... guardrail') is specific and distinguishes it from sibling tools like check_action or run_tests, which evaluate instead of create.

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 primary use case (creating rules) and contrasts itself with LLM-judge-based approaches, providing clear context. However, it does not explicitly say 'use this instead of X' or mention any exclusions, such as when to use check_action instead.

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

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

With no annotations, the description carries the full burden. It discloses that the tool returns 'pending or complete' and that the api_key is returned when payment completes after signup. It also implies polling behavior. However, it does not mention error cases or what happens with invalid session_ids, but for a simple status check this is transparent enough.

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

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

The description is two sentences with no wasted words. It front-loads the main purpose, then specifies return values and usage timing. 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?

With no output schema, the description explains the return values (pending, complete, api_key) and when to call. It lacks details on error handling or polling intervals, but for a tool with one parameter and a straightforward purpose, it is fairly complete.

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

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

The input schema has 100% coverage for the single parameter, describing it as 'The session_id returned by create_account_card or top_up_card.' The description reinforces this same context but does not add new meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool checks the status of a Stripe card payment and returns pending or complete, with a special api_key return on completion after signup. It also references specific sibling tools (create_account_card, top_up_card) as prerequisites, distinguishing it from other check_* 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 explicitly says 'Call this after create_account_card or top_up_card once the user has paid,' providing clear usage timing. It does not explicitly exclude alternatives or list when not to use, but the context is strong enough to guide selection among 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?

No annotations are provided, so the description carries the full burden. It discloses several key behaviors: returns only ALLOWED/BLOCKED, omits proof details, uses the same formal verification under the hood, is a minimal response, and costs 1 credit. This goes well beyond the schema and gives clear operational context.

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

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

The description is two sentences with no wasted words. It front-loads the purpose, then provides usage context, cost, and authentication requirements. 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 three-parameter tool with fully described schema, the description adequately covers the return format (ALLOWED/BLOCKED), the use case, and the lightweight nature. No output schema exists, but the description's mention of the minimal response compensates. The tool is complete and ready 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?

Schema description coverage is 100%, with each parameter (policy_id, action, api_key) already clearly documented. The tool description does not add any additional parameter semantics beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool's function: 'returns only ALLOWED or BLOCKED with no proof details.' It uses a specific verb ('returns') and resource ('yes/no guardrail verdict'), and distinguishes itself from siblings that provide full SAT/UNSAT reports or ZK proofs.

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?

Explicitly states when to use: 'Use when you need a lightweight gate and don't need the full SAT/UNSAT report or ZK proof.' It also clarifies that it performs the same formal verification as heavier alternatives, helping the agent choose between this and sibling tools like check_action.

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

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

No annotations are provided, so the description must carry the burden of disclosing side effects, read-only behavior, and what results look like. It mentions 'requires api_key' and the purpose, but does not state whether this op is read-only, whether it costs money, or what output is returned. This is a significant gap for a tool that executes tests.

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

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

Two sentences, front-loaded with the action and purpose, then workflow, then requirement. No filler; every sentence adds value.

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

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

The tool is simple (2 params, no output schema), but the description leaves gaps: it mentions 'saved test cases' without explaining how they are created or selected, and does not describe the nature of the results. The workflow clue partially compensates, but return behavior is unspecified.

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

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

Schema coverage is 100% with descriptions for both parameters. The description only repeats that api_key is required and does not add meaning beyond the schema. Baseline 3 applies because the schema handles parameter semantics.

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

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

The description uses a specific verb+resource pair: 'Run saved test cases against a policy.' It clearly states the tool's goal (confirm blocking/allowing) and distinguishes it from siblings like make_rules (create rules) and quick_check (single action check).

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 workflow guidance: 'Run this after make_rules and before using the policy in production.' This tells the agent when to use it, though it does not name alternative tools for single checks or other 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 disclosure burden. It reveals the payment method, cost, and authentication need (api_key). It doesn't mention processing time or return format, but for a simple top-up operation, the transparency is adequate.

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

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

Two sentences, front-loaded with the main action and payment method. The alternative is given in the second sentence. No wasted words.

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

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

For a one-parameter tool with no output schema and no annotations, the description covers the essential context: what it does, how payment works, and when to use a different tool. Minor omissions like success feedback or timing are acceptable given the 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 coverage is 100% with the single api_key parameter already described. The description only repeats 'Requires api_key' without adding extra meaning, so it meets the baseline but does not exceed it.

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

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

The description clearly states the exact action: adding 500 credits to the account via a specific payment method (x402 USDC on Base). It also distinguishes from the sibling tool top_up_card, making 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?

Explicitly provides an alternative: 'Use top_up_card instead for credit card payment with volume discounts.' This tells the agent when not to use this tool and points to the correct alternative. Also mentions the api_key requirement as a prerequisite.

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

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

With no annotations, the description carries full responsibility. It discloses that the tool returns a 'checkout_url' (indicating it initiates a payment flow rather than directly crediting), that credits never expire, and that an API key is required. This is valuable behavioral context beyond what the schema provides.

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 concise and front-loaded with the main action. The tier list is necessary for parameter comprehension, and the additional notes (never expire, requires api_key) are brief. No filler, though the tier list makes it slightly longer than strictly needed.

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 only two parameters and no output schema, the description covers the key aspects: purpose, accepted amounts, bonus structure, expected return (checkout_url), and a requirement (api_key). It does not explain the full payment flow or what happens after the checkout URL is used, but that is likely handled outside this tool.

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

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

The schema already covers both parameters (amount_usd and api_key) with descriptions, so baseline is 3. The description enriches the amount_usd parameter by adding the exact credit bonuses for each tier ($5 → 500 credits, $10 → 1,050, etc.), which goes beyond the simple allowed-values list 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 opens with 'Add credits via credit card', a specific verb+resource+payment method. It clearly distinguishes from the sibling tool 'top_up' by specifying the credit card payment path, and the rest of the description details the volume bonus tiers.

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 is the tool to use when paying via credit card, and provides detailed tier options. It does not explicitly name alternatives or state when not to use it, but the credit card context gives clear usage guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It covers key traits: independent verification without re-execution, under one-second runtime, no additional cost, required wait time, and single-use per proof. This is strong for a tool with no annotations, though it stops short of detailing error behavior or what happens with invalid/expired proof IDs.

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

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

The description is a compact paragraph where every sentence earns its place: purpose, benefit, verification speed, cost, timing, and usage constraint. It is front-loaded with the core purpose and avoids any 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?

Despite having no output schema or annotations, the description gives sufficient operational context for an agent to invoke the tool correctly: what it does, when to use it, how long it takes, cost, and constraints. It could be more complete by specifying failure modes or response shape, but for a straightforward verification tool, it covers the essentials well. Given the tool's simplicity, a 4 is appropriate.

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

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

The input schema already documents proof_id as the UUID returned by a prior call, so 100% schema coverage means the baseline is 3. The description adds value beyond the schema by explaining the single-use nature and the wait-a-few-minutes timing, which are crucial for correct parameter handling. It also reinforces that the proof_id comes from prior check_action/paid calls, aligning with the schema.

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

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

The description clearly states the tool's purpose: 'Independently verify a ZK proof from a prior check_action call.' It uses a specific verb ('verify') and resource ('ZK proof'), and explicitly distinguishes from sibling tools by noting it confirms the check 'without re-running it.' This makes it unmistakable what the tool does and how it differs from check_action.

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

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

The description provides clear usage context: use after a check_action, wait a few minutes for the proof to be generated, and note the single-use constraint. It also implies an alternative (re-running the check) and explains why you'd use this instead. However, it doesn't explicitly name sibling alternatives or state when NOT to use it, so a perfect 5 isn't warranted.

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