Sats4AI - Bitcoin-Powered AI Tools

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

Annotations provide destructiveHint and openWorldHint; the description adds async behavior, auto-retries, cost estimates, languages, and possible 'pending_confirm' state with no contradictions.

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?

Long but well-structured with front-loaded purpose and clear sections for details and alternatives; every sentence adds value but could be slightly more concise.

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 complex tool with no output schema, the description covers return format (transcript, pending_confirm), async polling, payment, and multilingual support comprehensively.

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

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

Schema coverage is 100%, but the description enriches parameters with language guessing logic, duration default, and payment flow context, adding value beyond schema.

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

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

The description clearly states the tool sends an AI voice agent to handle calls requiring human interaction, and distinguishes it from siblings like open_voice_bridge, place_call, and send_sms.

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 specifies when to use (tasks needing a human) and when not to use (e.g., for own LLM, one-shot TTS, SMS), including prerequisites like create_payment.

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 provided, so description carries full burden. Discloses model (Qwen VL), capabilities (OCR, chart reading, spatial reasoning), pricing, and a critical behavior warning about PDFs causing hallucinations. Missing info on async vs sync and error handling.

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

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

Description is concise with only necessary sentences. Front-loads the core purpose. Minor redundancy: payment info could be separate but not detrimental.

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

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

Covers purpose, usage, behavioral traits, and payment. Missing clarity on return format (presumably text) and whether results are synchronous. With 4 params and no output schema, some gaps remain.

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

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

Schema covers all 4 parameters with detailed descriptions, so baseline is 3. Description reinforces the PDF warning for imageBase64 parameter but adds no new semantic value beyond schema.

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

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

Description clearly states the tool analyzes images, answers visual questions, and extracts information. It distinguishes from sibling extract_document by explicitly noting single images only.

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 (visual analysis) and when not (PDFs/multi-page documents, recommending extract_document). Also mentions payment requirement and cost (21 sats per image).

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

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

No annotations are provided, so the description carries full burden. It discloses async behavior, payment requirement (create_payment), resolution options (480p/720p/1080p), duration range, per-second pricing, Bitcoin Lightning payment, and no API key needed. It mentions native audio. It does not cover failure modes or error handling, but the transparency is high for a paid async 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 concise and well-structured, front-loading the core purpose. Every sentence adds value: what it does, async nature, resolution, duration, pricing, payment method, and prerequisite tool call. It is slightly long but efficient for the amount of information conveyed. No redundancy.

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

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

Given no output schema, the description only mentions 'returns requestId' but does not describe the output format or what poll results contain. It also lacks input constraints (max image size, format). For a tool producing video output, more details on the return structure would improve completeness. The description is adequate but has clear gaps.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value beyond the schema by noting the optional last frame and pricing per second for resolution, but it does not detail the last frame parameter (which is absent from the schema). This could cause confusion. The description does not fully compensate for the missing param info, but the schema itself is descriptive.

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: animating a still image into a cinematic video using ByteDance Seedance 2.0, with a first frame and optional last frame plus a motion prompt. It distinguishes itself from siblings like generate_video by specifying the input (still image) and output (video animation). The verb 'animate' and resource 'still image' are specific and not a tautology.

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 tells when to use the tool: to animate a still image. It provides clear instructions: requires create_payment first, async with polling via check_job_status, and pricing details. It does not explicitly contrast with sibling tools (e.g., generate_video) but gives enough context on prerequisites and workflow. A slight deduction for missing explicit 'when not to use'.

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?

Annotations declare readOnlyHint and idempotentHint as true. Description consistently describes a read-only wait-and-retrieve operation with no side effects. Adds behavioral context: streaming support, ~4-minute wait timeout, timed_out flag, and need for repeated calls, which goes beyond annotation details.

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

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

The description is a single paragraph that packs many details efficiently. Each sentence adds value (purpose, usage, modes, timeout, equivalents). Slightly dense but still well-structured, earning a 4 for conciseness.

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

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

Given the tool's complexity, the description covers all essential aspects: core function, parameter usage, streaming vs. polling modes, timeout behavior, and how to handle incomplete jobs. It also mentions it's free and equivalent to two other tools, providing a complete understanding without needing external references.

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 both parameters fully described. The description only restates 'Pass the requestId + jobType' without adding new semantic meaning beyond what the schema already provides. Therefore, score is baseline 3.

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 waits for an async job and returns its result in one call, eliminating manual polling. It specifies the verb 'wait' and 'return', the resource 'async job result', and distinguishes itself from polling loops and sibling tools check_job_status and get_job_result.

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 instructs to pass requestId and jobType from specific async tools. Describes streaming vs. non-streaming behavior based on Accept header, timeout handling, and when to call again. Contrasts with polling by stating equivalence to check_job_status + get_job_result combined.

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

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

With no annotations provided, the description fully discloses behavioral traits: barcode preservation, pricing per pass, refund policy for plain images, privacy (in-memory, no storage, 30-min expiry), and Lightning payment. No contradictory or missing critical info.

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

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

The description is thorough but efficient. It front-loads the core purpose, then adds pricing, refund policy, privacy, and payment details in a logical order. Every sentence provides value, though it could be slightly trimmed.

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 3 parameters and no output schema, the description covers input format, behavior, error handling (refund), pricing, privacy, and output structure (save links). No gaps remain for correct invocation.

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

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

Schema coverage is 100%, so baseline is 3. The description adds context: documents vs. documentBase64, 'one per file' for family/booking, and refund for blurry photos without readable barcode. This extra nuance justifies a 4.

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 starts with a clear verb ('Turn') and specifies the resource (airline boarding passes) and the specific enriched output (Google Wallet passes with boarding zone, gate, boarding time). It also mentions handling multiple passengers, which distinguishes it from simple PDF conversion tools 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 explains when to use the tool: for boarding passes as PDF/screenshot. It provides pricing details and payment flow via create_payment, plus refund conditions for no-extra-field images. However, no explicit comparison to sibling tools or exclusion of non-boarding-pass documents.

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?

Annotations provide idempotentHint=true, which is consistent. The description adds significant behavioral context: return JSON structure, progress for epub-audiobook, polling interval, error handling (do not retry on fail), and distinction from synchronous tools. No contradictions.

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: purpose first, then return format, polling instructions, and usage boundaries. Every sentence contributes 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?

Given the complexity of multiple async tools and sibling tools like get_job_result, the description provides complete guidance. It explains when to use this tool, how to interpret results, and what to do next, compensating for the lack of output schema.

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

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

Schema coverage is 100%, so parameter names and descriptions are present. The description adds valuable semantics: mapping jobType enums to tool names (e.g., video=generate_video) and explaining non-obvious values like video-fal-standard. This enriches the schema information.

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

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

The description uses specific verb 'Poll the status' and resource 'async job'. It clearly lists which async tools produce requestIds and distinguishes from synchronous tools like generate_image. The purpose is unambiguous and well-scoped.

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 (after async tools that return requestId), polling interval (5-10 seconds), next step on completion (call get_job_result), and what not to do (do not retry on failure, do not use for synchronous tools). Also notes the tool is free.

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?

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds valuable behavioral context: the tool is free, does not require payment, explains the 'readyToUse' flag, mentions instant payment for most MCP clients, and details invoice expiration. No contradictions with annotations.

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

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

The description is concise (5 sentences) and front-loaded with the main purpose. Every sentence adds value: purpose, return fields, usage, expiry, and cost. No redundant or unnecessary 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 simple one-parameter tool with full schema coverage and annotations, the description is nearly complete. It explains the return JSON, usage flow, expiry, and cost. However, it lacks error case handling (e.g., invalid paymentId) and could elaborate on the exact response shape, but these are minor gaps.

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 parameter 'paymentId' already described as 'The paymentId returned by create_payment.' The description does not add additional parameter semantics beyond what the schema provides, so a baseline of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Check whether a Lightning invoice has been paid.' It specifies the verb 'check' and the resource 'Lightning invoice payment status.' The return JSON fields are explicitly listed, distinguishing it from related tools like create_payment.

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 explicit usage guidance: 'Call after create_payment to verify the user has paid before calling the target tool.' It also notes invoice expiry (10 minutes) and that a single check is usually sufficient, offering clear context for when and how to use the 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 provided, so description bears full burden. Discloses pricing, payment requirement, output type, and quality modes. Lacks details on file format constraints, duration limits, or error conditions, which would improve 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?

Three focused sentences: purpose/output, quality modes, pricing/payment. Every sentence adds value, no fluff, front-loaded with most important 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?

Covers main purpose, inputs, modes, payment requirement, and output type. No output schema, but description mentions voice_id. Missing file format and size constraints, but overall adequate for a tool with 4 parameters and 100% schema coverage.

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% (all 4 parameters described). Description adds context: explains paymentId must be paid, voiceFileUrl must be public, and model enum meanings. Goes beyond schema by explaining the payment flow.

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

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

Clearly states 'Clone any voice from a single audio sample' and describes the output as a reusable voice_id for text-to-speech. Distinguishes from sibling tools like text_to_speech by explicitly linking the output.

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

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

Specifies prerequisite: requires create_payment with toolName='clone_voice'. Mentions cost (7,500 sats) and payment method (Bitcoin Lightning). Provides context on model selection (Turbo vs HD) but does not explicitly state when not to use the 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 provided, so description carries full burden. It discloses cost (5 sats), payment method (Bitcoin Lightning, no API key), and prerequisite step. Does not mention rate limits or time estimates, but otherwise transparent.

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

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

Four concise sentences with front-loaded purpose. No unnecessary words; every sentence adds value.

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

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

Given no annotations and no output schema, the description covers purpose, usage instructions, prerequisites, cost, and parameter details completely enough to use the tool.

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

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

Schema coverage is 100%, but description adds context: specifies that paymentId must be valid/paid, imageBase64 should be Base64-encoded grayscale/B&W image, and explains model_size enum and default.

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 explicitly states it colorizes black-and-white or grayscale photos, names the algorithm (DDColor), and highlights that it's impossible for text/vision LLMs, distinguishing it from 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?

Provides clear when-to-use guidance (colorizing B&W photos), mentions that it requires create_payment with toolName='colorize_image', and explains the pay-per-request model with Bitcoin Lightning.

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

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

Discloses that no new payment is needed and that it returns a call_id for polling. Annotations only provide openWorldHint, so description adds behavioral context. Could be improved by mentioning that answers are optional and the tool will proceed as-is if omitted.

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

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

Three well-structured sentences, each conveying essential information: action and context, prerequisite, financial implication, and return value. 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?

Despite no output schema, description specifies the return value (call_id for polling). It covers prerequisite, usage, financial impact, and next steps. Additional context like error handling would elevate but is not necessary 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 descriptions cover both parameters. Description adds value by explaining that 'answers' keys are question strings and values are answers, and that omitting them confirms as-is. This clarifies usage beyond schema.

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

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

Clearly states the action ('Confirm an AI call') and the context ('after reviewing push-back questions, optionally providing answers to missing info'). Distinguishes from sibling tool ai_call by specifying the prerequisite state 'pending_confirm'.

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 says when to use: 'Required when ai_call returns state="pending_confirm"'. Also notes financial aspect ('Uses the original payment — no new payment needed') and subsequent polling step ('Returns call_id for polling with check_job_status(jobType="ai-call")').

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 key behavioral traits: requires payment (100 sats), returns a download URL, preserves formatting and quality. Without annotations, it carries the burden and does so adequately, though it could mention rate limits or file size constraints.

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 front-loaded with the core purpose, then lists format categories, quality, return type, and payment model. Every sentence serves a purpose, though it could be slightly more concise.

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

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

Given the tool has 5 parameters, no output schema, and no annotations, the description provides sufficient contextual completeness: it explains the payment flow, the need for 'create_payment', and the expected output (download URL). The agent can use this to correctly 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?

With 100% schema coverage, baseline is 3. The description adds context about the conversion process and payment requirement but does not elaborate on parameter details beyond what the schema already provides.

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

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

The description clearly states the tool converts files between 200+ formats, listing categories like documents, images, audio, and video. The verb 'convert' and resource 'files between 200+ formats' make the purpose specific and distinct from sibling tools like 'convert_html_to_pdf'.

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 the pay-per-request model with Bitcoin Lightning and explicitly mentions the prerequisite of calling 'create_payment' with toolName='convert_file'. However, it does not provide explicit when-not-to-use guidance or compare to 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?

No annotations present, but description fully discloses return format (JSON with temporary URL, 1-hour validity), cost (50 sats), payment requirement (create_payment), and input support (HTML/CSS, base64 images). Transparent about all behavioral aspects.

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

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

Description is informative but slightly verbose; could be tightened. However, it is well-structured and front-loaded with the core purpose.

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

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

Given no output schema, description fully explains return format. Covers all essential aspects: input, format, output, cost, prerequisites, and alternatives. Complete for a tool with simple parameters.

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?

Although schema covers parameters 100%, description adds context: explains paymentId's origin, format options, and the purpose of html content. Also implies output structure beyond schema.

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

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

The description clearly states the tool converts HTML or Markdown to PDF, with specific use cases (invoices, reports) and distinguishes from sibling tool convert_file for existing file conversions.

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

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

Provides explicit when-to-use: generating documents, setting format='markdown' for Markdown. Also gives alternative: 'Use convert_file instead for converting existing files.'

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 provided, so the description carries the full burden. It discloses return format (JSON with paymentId, invoice BOLT11, amount, expiresAt), expiry time (10 minutes), and detailed pricing dependencies for various tools. It also covers error handling for missing parameters, making behavior very 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 comprehensive but verbose, with a run-on sentence listing tool-specific requirements. It could be more structured with lists or tables, but it is functional and every sentence provides 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?

Given the high parameter count and lack of output schema, the description covers return values, payment lifecycle, and error handling well. It explains the flow and default behaviors, though it doesn't detail invoice expiry consequences or rate limits, which are minor gaps.

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%, baseline 3, but the description adds substantial value beyond schema: it explains which parameters are required for each tool, pricing formulas (e.g., durationMinutes for transcribe_audio), defaults, and error behavior (under-counting rejected with exact price). This goes far beyond the schema descriptions.

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

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

The description clearly states 'Create a Lightning invoice to pay for one AI service call', using a specific verb and resource. It distinguishes from siblings by explaining the payment flow and that each payment covers exactly one call.

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 typical flow: list_models → create_payment → check_payment_status → call tool, and advises calling once per operation. It describes when to include modelId and which tools require extra parameters, though it does not explicitly state when not to use this tool.

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

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

No annotations are provided, so the description carries the full burden. It discloses processing time (~2 min), cost (20 sats per image), payment method (Bitcoin Lightning, no signup), and the requirement to call 'create_payment' with a specific toolName. This goes well beyond basic behavioral traits.

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

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

The description is well-structured with front-loaded purpose, then usage guidance, limitations, payment details. It is slightly verbose (e.g., list of benchmarks), but every sentence earns its place. Could be slightly shorter, but 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 complexity (payment integration, multiple task types, no output schema), the description is fairly complete. It covers what the tool does, when to use it, costs, and prerequisites. Missing output details are compensated by the clear process and known benchmarks.

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 context for 'paymentId' (needs to be paid) and hints at default behavior for 'task_type', but these are already covered in the schema. No significant added meaning beyond schema.

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

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

The description clearly states it recovers detail from camera-shake and motion blur, names the model (NAFNet), and explicitly lists what it is not effective for (e.g., intentional panning blur, bokeh). The verb 'recover detail' plus the resource 'deblur_image' provides a specific, actionable purpose.

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

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

The description provides explicit usage scenarios ('Best for: handheld shake, bumped camera...') and clear exclusions ('NOT effective for: intentional panning blur...'). It also mentions support for denoising, giving the agent guidance on when to select this tool over others.

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, so description must cover behavior. It discloses cost (2 sats), payment flow, faster/cheaper than LLM, and returns label and boolean. Does not mention rate limits or destructive effects, but nothing contradictory.

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?

Concise paragraph front-loads core function, then adds pricing and payment details. No redundant sentences; 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?

With no output schema, description explains return values. Covers use case, pricing, payment flow, and image format. Complete for a simple two-param tool.

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

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

Schema coverage is 100% with descriptions for both params. Description adds context: paymentId must be valid/paid, imageBase64 can be data URI or formats. Reinforces workflow requirement, adding marginal value beyond schema.

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

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

Description clearly states the tool classifies image safety into normal/suggestive/explicit, returns a label and boolean flag. It distinguishes itself from siblings like detect_objects by specifying NSFW detection and unique pricing.

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 use for content moderation pipelines and is cheaper/faster than LLM. Mentions payment requirement via create_payment. Lacks explicit when-not-to-use or alternative tools, but context is provided.

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 provided, so the description carries full burden. It discloses the model (Grounding DINO), the payment mechanism, and the type of output (bounding boxes, scores). However, it lacks detail on error handling, image size limits, or format restrictions 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 concise and front-loaded with the core purpose. Each sentence adds value, though the payment instruction could be slightly more integrated. 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?

The description covers the tool's purpose, output type, payment model, and prerequisites. It lacks explicit error scenarios but is fairly complete given good schema coverage and no output schema. Minor gaps in behavioral details.

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 all parameters. The description adds natural language context for the query parameter but does not elaborate on box_threshold or text_threshold beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool detects and locates objects by name, using Grounding DINO, and provides structured output (bounding boxes, confidence scores). This distinguishes it from sibling tools like 'analyze_image' or 'generate_image'.

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 the payment flow (5 sats per image, Bitcoin Lightning, no signup) and the prerequisite 'create_payment'. It contrasts with vision LLMs but does not explicitly mention sibling tools like 'analyze_image' as alternatives or specify when not to use this tool.

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

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

No annotations provided; description covers model used, return format (JSON with image URL), and pricing. Missing details on error handling, input constraints, or reversibility.

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?

Concise with essential information upfront, but could be more structured (e.g., separate sections for usage, pricing, parameters).

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?

Explains payment flow and resolution options, but lacks details on input image constraints, failure modes, and output schema. Adequate for a paid API tool with complex parameters.

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%; description adds context about payment requirement and pricing beyond schema, but other parameters like prompt and imageBase64 are already adequately described in schema.

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

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

Clearly states 'Edit an image with natural language instructions' and lists specific capabilities (object addition/removal, style transfer, inpainting), distinguishing it from siblings like generate_image or remove_object.

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

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

Provides payment flow instructions and resolution-tiered pricing, but does not explicitly specify when to use this tool vs. alternatives like remove_object or colorize_image.

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 provided, so description carries full burden. It discloses side effects: finalizes billing, returns refund link for unused deposit, and returns final transcript. Good disclosure beyond basic 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?

Two sentences, front-loaded with the main action, no unnecessary words. All information is essential.

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 one parameter and no output schema, the description adequately covers all needed information: what the tool does and what it returns.

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 a clear description for sessionId. Tool description adds no further detail beyond what the schema already provides.

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

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

The description clearly states the verb 'Hang up', the resource 'Voice Bridge call', and additional actions like finalizing billing and returning refund link and transcript. It effectively distinguishes from siblings like 'open_voice_bridge'.

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?

Implied usage after starting a voice bridge call, but no explicit guidance on when not to use or alternatives. Could mention that polling might be needed before ending.

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 fully carries the burden. It details async polling, voice tiers and costs, language behavior (chapter titles only on default tier), translate option, and auto-chapter selection caveats. Very comprehensive.

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 lengthy but each sentence adds necessary detail. It front-loads the main purpose. Slight room for streamlining, but overall well-structured.

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 9 parameters and no output schema, the description explains async return (jobId), polling, payment, and all side effects. It is complete for the tool complexity.

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

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

Schema coverage is 100%, but the description adds significant value: explains voice IDs, default behavior, language nuances, translate format, and chapter selection warnings. Exceeds baseline 3.

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

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

The description clearly states the tool converts EPUB/PDF/TXT to audiobooks with chapter detection, multi-voice, and translation. It distinguishes from siblings by its specific function, which none of the sibling tools perform.

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 the single-payment async model, prerequisites (paymentId), and that no API key is needed. It does not explicitly state when not to use or list alternatives, but the context is clear given the 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 fully bears behavioral disclosure. It covers key traits: legally binding nature, flat fee of 1000 sats, use of an established e-sign provider, delivery of signed copy via email, privacy (PDF processed in memory, never stored), and payment requirements. No contradictions.

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 (five sentences) and front-loaded with the core purpose. Every sentence adds value—payment, process, privacy, and prerequisite are all included 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?

Given the tool's complexity (5 parameters, no output schema), the description is complete. It explains input (PDF, signers, email), process (signed copy emailed after all sign), privacy, and payment. The output is adequately described as an email with the signed copy.

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 baseline is 3. The description adds context beyond schema: 'name up to 3 signers' and 'give the email where the signed copy should land', clarifying parameter roles. This slightly elevates the score.

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

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

The description clearly states the tool's purpose with a specific verb ('send') and resource ('document out for legally binding e-signature'). It distinguishes itself from sibling tools, most of which are unrelated (image/audio/AI tasks), making it easy to identify.

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 the prerequisite (requires create_payment with toolName='e_signature') and payment method (Bitcoin Lightning). It implies when to use but does not explicitly state when not to use or provide alternatives, though it's sufficient for correct usage.

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

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

No annotations provided. Description discloses cost (10 sats/page) and payment flow, but lacks details on size limits, supported languages, error handling, or whether operation is destructive. Adequate but not exhaustive.

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

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

Four sentences, front-loaded with purpose, then capabilities, cost, and prerequisite. 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?

Covers key aspects: purpose, capabilities, cost, payment prerequisite. Lacks output format detail (though Markdown is mentioned) and error handling. No output schema to compensate, but overall sufficient for typical use.

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

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

Schema covers 100% of parameters with descriptions. Description adds value by explaining the paymentId must be obtained via create_payment and that documentBase64 is base64 encoded, beyond schema details.

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

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

The description clearly states it extracts text from PDFs and images as clean Markdown, specifying handling of complex layouts, tables, handwriting, etc. This distinguishes it from siblings like analyze_image or convert_file.

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 mentions prerequisite payment via create_payment with toolName and quantity, and that no API key is needed. Does not compare to alternatives like convert_file for document extraction, but the context 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, the description carries the burden. It discloses critical behaviors: dual-model pipeline, handling of difficult inputs, and notably the fabrication of data for non-receipts (via parameter description). It also explains the payment flow. Minor gaps exist, such as lack of explicit error handling or response format details.

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

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

The description is concise with five sentences, each adding value: purpose, pipeline, output, capabilities, pricing, and payment requirement. It is front-loaded with the core purpose and contains no redundant or irrelevant content.

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

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

The description covers the tool's purpose, output structure, handling of difficult inputs, pricing, and payment flow. It lacks explicit information on error handling, synchronous/asynchronous behavior, and document size limits, but overall provides sufficient context for 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 100%, so baseline is 3. The description adds context about the payment requirement and document types, but the parameter descriptions in the schema already include the key note about non-receipts. The added value beyond schema is moderate.

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

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

The description clearly states it extracts structured data from receipts, invoices, and financial documents, with specific output fields. However, it does not explicitly differentiate from sibling tools like 'extract_document', which may have overlapping functionality.

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 use for receipt/invoice/financial document extraction but provides no explicit guidance on when to use versus alternatives. It mentions the payment requirement and capabilities but lacks when-not-to-use or alternative tool comparisons.

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

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

Discloses async nature (returns requestId, poll with check_job_status), pricing (350 sats), payment requirement (create_payment), and model provider. No contradictory annotations. Some details like error handling are omitted, but overall good.

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?

Five concise sentences covering purpose, inputs, async behavior, pricing, and prerequisite. Front-loaded with the core function.

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

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

Covers key aspects: input options, async flow, payment, polling tool. No output schema, but description explains return value and follow-up. Could include more on errors, but adequate for a simple generation 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 descriptions cover 100% of parameters. Description reinforces the mutual exclusivity of prompt and imageBase64 but adds no new information 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?

Clearly states the tool generates a textured 3D GLB model from either a photo or text prompt, using Tencent Hunyuan3D. Distinguishes from sibling generation tools by specifying the input types and model source.

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

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

Provides clear instructions: provide exactly one input (photo or text), async with polling, requires payment. Does not explicitly mention when not to use or compare to alternatives, 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?

No annotations provided, so description carries full burden. Discloses payment model, model upgrade policy, and img2img support. Lacks details on rate limits, error handling, or synchronous vs. async execution.

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?

Very concise and front-loaded: two sentences cover purpose, return format, models, payment, and img2img. 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?

Covers key aspects: purpose, payment, models, img2img. Missing guidance on asynchronous behavior (if any) and how to retrieve results (e.g., polling). No mention of output schema, but that is not required.

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

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

Schema coverage is 100%, but description adds value by explaining modelId defaults, naming models with costs, and clarifying imageBase64 for img2img. Slightly redundant with schema but helpful.

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 an image from a text prompt' and mentions img2img, clearly distinguishing from siblings like animate_image or edit_image.

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 requires create_payment with toolName='generate_image', lists model options with costs, and notes no API key needed. Does not compare with siblings for when to use this vs. other image 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, description carries full burden. It discloses output format (MP3 URL), model version (Music-2.6), accuracy claim (99%+), and pricing (300 sats). Lacks typical latency or error details, but covers essential behavioral traits.

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

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

Five sentences with no wasted words. Front-loaded with core purpose, then model info, usage instructions, output, and prerequisite. Every sentence adds value and the structure is logical.

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, description adequately explains return value (MP3 URL) and payment flow. Could be more complete with error handling or latency info, but provides enough context for an agent to use the tool effectively.

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 baseline is 3. Description adds context by reinforcing how to use prompt (e.g., 'Specify BPM, key...') and lyrics with section tags, but does not introduce new meaning beyond schema.

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

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

Description clearly states 'Generate full songs (up to 6 min)' with specific features (AI vocals, BPM/key control, section tags). This distinctively separates it from sibling tools like generate_text, generate_image, etc., leaving no ambiguity about what the tool does.

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

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

Description provides explicit guidance: specify BPM, key, genre, mood in prompt; requires a payment via create_payment with toolName='generate_music'. While it doesn't mention when not to use or alternatives, the unique nature of music generation makes this adequate.

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

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

No annotations are provided, so the description carries the full burden. It discloses pricing (per-character), model details, default model, payment requirement, and automatic upgrades. Missing details on rate limits or error handling, but provides sufficient transparency for an AI agent.

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 distinct information (models, pricing, features, prerequisites). 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?

With 8 parameters and no output schema, the description covers core functionality, payment flow, model options, and features. It lacks output format details but is otherwise complete for typical use.

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%, yet the description adds significant value beyond the schema: it explains payment requirement, model IDs with context, and specific use cases for fileContext and imageBase64. This deeply enriches parameter understanding.

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

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

The description clearly states it generates text using frontier AI language models, lists specific models with details, and mentions capabilities like document Q&A and vision analysis. This distinguishes it from sibling tools that generate other media (e.g., images, music).

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 the payment prerequisite, no signup requirement, and stable endpoints. It provides clear context for when to use the tool, though it does not explicitly contrast with alternatives or state when not to use it.

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

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

No annotations provided, so description carries full burden. It discloses async behavior, payment requirement, pricing model (per second by resolution, BTC-pegged), and that native audio is free. No contradictions, though it omits potential rate limits or errors.

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

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

The description is a single paragraph but covers all critical aspects concisely. It could be slightly more structured (e.g., bullet points) but is not overly verbose.

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 complexity (async, payment-required, multiple parameters), the description sufficiently covers the end-to-end workflow: payment prerequisite, parameter usage, polling. No output schema exists, so return values are adequately implied.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining the payment flow relation (create_payment with toolName and duration/resolution), mapping legacy resolution modes, and emphasizing that paymentId must be paid.

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 generates cinematic video from text, specifies the model (ByteDance Seedance 2.0), and mentions key features like synchronized audio. It differentiates from sibling 'generate' tools by focusing on video and audio generation.

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 the async workflow (returns requestId, poll with check_job_status) and explicitly requires a prior create_payment call with specific parameters. It does not explicitly exclude alternative tools but provides sufficient context for when to use it.

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

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

Annotations already set readOnlyHint=true and idempotentHint=true. Description adds 'No payment required, no side effects' which reinforces safety. Also describes return values (amount_sats, breakdown, currency). No contradictions.

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?

Four sentences, no filler. Front-loaded with purpose. Every sentence adds value: purpose, usage context, examples, return format, alternative behavior.

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

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

Covers purpose, usage, examples, return fields, and behavior with/without params. No output schema but description mentions return structure. Could clarify that service must be a valid identifier from catalog, but that's minor.

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 each param. Description adds real usage examples (service=text-to-speech&chars=1500) and explains that omitting params lists all services. This goes beyond schema details.

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 clearly states it provides an exact sat cost quote for a service before payment. Verb 'Get' and resource 'cost estimate' are specific. Distinguishes from sibling tools like create_payment, check_payment_status by focusing on pre-payment price checking.

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 says 'Useful for budget-aware agents to price-check before committing' which sets context. Provides example usage patterns (service=...). Does not explicitly state when not to use or alternatives, but context from sibling tools implies this is the estimation step.

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

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

Annotations already declare readOnly and idempotent hints; the description adds 'No payment required' as extra behavioral insight, without contradicting annotations.

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

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

Two sentences: the first states the purpose with concrete examples, the second gives actionable usage guidance. No wasted words, front-loaded with key info.

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 purpose and usage guidance for a simple no-parameter tool; while it could detail the output format, the examples suffice for an agent to understand the expected 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?

No parameters exist, so schema coverage is complete; the description naturally has no need to explain parameters, meeting the baseline for 0-param tools.

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 explicitly states the tool retrieves a machine-readable catalog of error codes, with specific examples, clearly distinguishing it from sibling tools by focusing on error code retrieval.

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 advises branching on error_code over parsing text and notes no payment required, providing clear context for when to use this tool, though it does not explicitly exclude 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?

Annotations already declare readOnlyHint and idempotentHint. Description adds: error on non-completed, temporary URLs (~1 hour), output shape per jobType. No rate limits or idempotency details needed beyond annotations. Value added beyond annotations.

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

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

First sentence declares purpose and main guideline. Subsequent sentences add output shapes and warnings. Each sentence adds value; not overly verbose. Could be more compact but well-structured.

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, but description provides complete output shapes per jobType, URL expiration, and prerequisite (check_job_status). Also includes sibling differentiation and restrictions. Thorough and 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?

Schema coverage is 100% so baseline 3. Description adds: jobType must match original tool's jobType and explains fallback types; requestId same as used with check_job_status. Adds meaningful context beyond schema.

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

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

Clearly states 'Retrieve the final output of a completed async job', specifying verb (retrieve), resource (final output), and condition (completed async job). Distinguishes from sibling check_job_status which only checks status, not retrieves results.

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 says 'Call ONLY after check_job_status returns status="completed"'; warns of error on non-completed jobs; tells not to use for synchronous tools. Provides clear context for when to use vs. 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?

Annotations already declare readOnlyHint and idempotentHint. The description adds 'No payment required,' which provides some additional behavioral context, but does not elaborate on rate limits, data freshness, or other important traits for a read operation.

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

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

Two sentences, no fluff, immediately states purpose and a key behavioral note (no payment). Excellent front-loading.

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, read-only tool with one parameter and no output schema, the description covers the core function. It could mention what kind of pricing is returned (e.g., per unit) but is sufficient for basic use.

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 modelId described as 'The AI model database ID.' The description adds no further parameter details, such as examples or constraints, 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 'Get pricing for a specific model by ID' clearly states a specific verb and resource, directly matching the tool name. It distinguishes itself from similar tools like get_cost_estimate by focusing on exact pricing for a specific model.

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

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

No guidance is provided on when to use this tool versus alternatives like get_cost_estimate or list_models. It does not mention prerequisites or typical use cases beyond needing a model ID.

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?

Annotations declare readOnly and idempotent hints. Description adds: 'This tool is free, requires no payment, and is idempotent — safe to call repeatedly,' reinforcing and expanding on annotations.

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

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

Description is concise yet thorough, front-loading the purpose and adding details about return format and usage. Every sentence serves a purpose.

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

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

For a read-only, idempotent tool with no output schema, the description fully explains the return JSON fields, default model behavior, and safety, leaving no gaps for an agent to infer.

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

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

Schema already has 100% coverage: category is well-documented with enum and description. Description adds 'Filter by category to narrow results to a specific tool,' which adds minimal value beyond the schema.

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

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

Description clearly states the tool's purpose: 'Discover available AI models with numeric IDs, tier labels, capabilities, and per-call pricing in sats.' It is distinct from sibling tools like get_model_pricing by focusing on discovery and selection.

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 instructs to call before create_payment to find the right modelId and mentions filtering by category. Provides clear context but does not explicitly state when not to use it (e.g., if modelId already known).

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?

Annotations already indicate readOnlyHint and idempotentHint. Description adds that it returns a sorted JSON array with specific fields, and that it's safe to call repeatedly, providing useful behavioral context beyond annotations.

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

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

Extremely concise: three sentences that front-load the purpose, then detail output and usage guidance. Every sentence earns its place.

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

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

Given no parameters and no output schema, the description fully specifies the return format and behavior. No gaps remain for an agent 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?

No parameters exist, so baseline is 4. Description adds value by explaining the output format and sorting, which helps an agent understand what the tool returns without needing parameter details.

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 uses specific verb 'List' and resource 'planned services' with current vote counts. It distinguishes from sibling tools like vote_on_service by clarifying this is for viewing, not voting.

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 no payment required, it's a free discovery tool, and directs to use the slug values with vote_on_service for casting votes. This clearly explains when to use this tool versus 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?

No annotations provided, so description fully carries the burden. It discloses bookmark preservation, temporary URL, cost, concatenation order, and payment requirement. Minor omission: no error handling details.

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

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

Concise and well-structured: first sentence states purpose, each subsequent sentence adds critical details without redundancy. 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 no output schema and no annotations, the description fully explains return format, temporary URL, pricing, and alternative tool, making it 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?

Schema coverage is 100%, so baseline is 3. Description adds value by specifying base64 encoding, minimum files, and concatenation order, slightly improving clarity.

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

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

The description clearly states 'Merge multiple PDF files into a single document' with specific verb and resource. It distinguishes from the sibling 'convert_file' by mentioning format conversion as an alternative.

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

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

Explicit when-to-use: 'Use convert_file instead if you need format conversion'. Also provides constraints like 'Minimum 2 files, no maximum' and payment details.

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?

Describes behavior: live session with primitives (say, poll, end), refund via LNURL-withdraw, privacy (in-memory transcripts, garbage-collected after 30 min, audio not persisted), payment via Bitcoin Lightning. No contradiction with annotations.

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

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

The description is well-structured with clear sections: purpose, usage, privacy, payment. It is informative but somewhat lengthy; each sentence adds value, though some redundancy with schema descriptions.

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

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

Covers all aspects: purpose, usage, workflow (links to sibling tools), privacy, payment, parameters. No output schema, but description explains that transcripts come via poll_voice_bridge, making it complete for the tool's role.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning beyond schema by explaining defaults (codec, sttEnabled, ttsEnabled), workflow (create_payment first), and refund address purpose. Also provides context for language parameter.

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

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

The description clearly states the tool's purpose: 'Open a Voice Bridge session: a live phone call where YOUR LLM is the brain.' It distinguishes from siblings by explaining when to use it (private, self-driven) and when not to (use ai_call, place_call).

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 usage guidelines: use for private self-driven calls, not for fully-managed (ai_call), not for one-shot TTS/IVR (place_call). Also specifies prerequisite: requires create_payment with specific parameters.

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?

Annotations mark destructiveHint true, but the description adds context about Bitcoin Lightning payment and no telecom account. It does not fully explain the destructive nature (e.g., cost incurred, irreversibility). No contradiction with annotations.

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

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

The description is concise (3 sentences), front-loads the core purpose, and includes all necessary context without extra words. Every sentence adds value.

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

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

The tool has 5 parameters and no output schema. The description covers the basic operation and prerequisites but does not explain what happens on completion, error cases, or whether it is synchronous/asynchronous. More detail would be beneficial given the lack of output schema.

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

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

Schema coverage is 100% with descriptions. The description adds minimal extra meaning beyond the schema, such as the mutual exclusivity of 'message' and 'audioUrl' and the requirement for 'durationMinutes' with audioUrl. 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 purpose: 'place an automated phone call to deliver a spoken message or play audio to any number.' It uses a specific verb ('place'), resource ('phone call'), and distinguishes from sibling tools like 'send_sms' or 'ai_call'.

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 the tool: 'notifying a human, delivering alerts, or reaching someone who isn't online.' It also mentions the prerequisite of using 'create_payment' with specific parameters. However, it does not explicitly exclude alternative tools or provide when-not-to-use 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 provided, so description carries full burden. It mentions returns types (partial + final transcripts, system events) and payment, but lacks disclosure on side effects, idempotency, or safety (e.g., read-only nature). Adequate but not comprehensive.

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

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

Three sentences: core function, return types, usage advice. No fluff, front-loaded with essential info.

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, description explains return types but not structure details or error handling. Parameter count low, usage guidance provided. Lacks depth on potential empty returns or system events composition.

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 100% with descriptions. Description adds default for cursor (0) and origin of sessionId. Text clarifies polling behavior and cursor usage, exceeding schema info.

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 specifies the verb 'Fetch', resource 'transcript events from an open Voice Bridge call', and scope 'since the last cursor'. It clearly distinguishes from sibling tools like voice_bridge_say and end_voice_bridge.

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 says to poll in a loop at ~500ms-1s interval and notes no additional payment. Provides clear usage context but does not mention when not to use or contrast with 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?

Despite only the 'openWorldHint' annotation indicating external interaction, the description richly discloses behavioral traits: 24-hour receive window, caller ID matching (last 10 digits), email delivery, optional OCR (+200 sats) with partial refund on failure, optional HMAC-signed webhook callback, and the no-refund policy to prevent squatting. Payment via Lightning is also noted. These details go well beyond the annotation's minimal information.

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

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

The description is a single paragraph of ~120 words, efficiently covering the main purpose, constraints, optional features, and policies. It is front-loaded with the primary use case. While dense, every sentence adds necessary information, making it concise for the tool's complexity. Minor improvement could be bullet-style structure, but current form is clear.

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

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

Given no output schema, the description effectively explains the delivery process (email, OCR, webhook) and constraints. It covers the immediate action (opening a window) and post-delivery behavior. However, it does not describe the immediate tool response (e.g., a confirmation or window ID), which may be needed for subsequent steps. Still, the description is fairly complete for a tool with offline delivery.

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 each parameter having a description. The description adds value by explaining the OCR add-on cost, the HMAC-signed webhook behavior, and the caller ID matching for fromNumber. It contextualizes the parameters within the use case. However, it does not add significant detail beyond the schema for email, paymentId, and callback_id, keeping the score just above baseline.

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

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

The description clearly states the tool's purpose: 'receive a fax' at a shared number, with delivery to email. It specifies the use case ('when expecting a fax back') and distinguishes from sending (sibling 'send_fax' exists). The verb 'receive' and resource 'fax' are specific, and the description contrasts with dedicated number rental, making purpose unambiguous.

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

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

The description provides explicit context for when to use the tool ('When you're expecting a fax back') and mentions the 24-hour window and no-refund policy. It does not directly state when not to use it, but the context is clear. Alternative tools (like send_fax) exist among siblings, but no explicit exclusion is given. The guidance is helpful but lacks explicit 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?

No annotations, but description fully discloses model (BiRefNet), edge cases handled, auto-upgrades, pricing (5 sats), and no-signup requirement. No contradictions.

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?

Concise yet informative; front-loaded with main purpose. Could trim technical detail but not excessive.

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?

Complete for a 2-param tool with no output schema: explains return value (transparent PNG), payment dependency, and model details.

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 description adds context: paymentId must be from create_payment, imageBase64 supports data URI and formats (PNG, JPEG, WEBP).

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

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

Clearly states 'Remove background from any image, returning transparent PNG.' Specific verb+resource, distinguishes from sibling 'remove_object' and others.

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?

Describes when to use (background removal), mentions prerequisite payment flow with 'Requires create_payment with toolName=remove_background.' No explicit when-not-to-use, but context 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, the description carries the full burden. It discloses the payment model (400 sats, Bitcoin Lightning, no API key), the underlying models (Grounding DINO + Bria Eraser), and the workflow (pay per request). It doesn't detail output format or failure modes, but it does reveal the key behavioral aspects of cost and required payment.

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

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

The description is well-structured and front-loaded: it opens with the core purpose, then adds model details, then payment information. Each sentence earns its place without redundancy, staying under 60 words while covering all key aspects.

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?

While the description covers payment and usage, it does not mention the output format or whether the tool returns the edited image directly or a job ID. Given the absence of an output schema, this information is important for the agent to understand the result of the call. The complexity is moderate, and the payment workflow is well covered, but the missing output description is a clear gap.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by providing concrete example values for the 'query' parameter ('person', 'car', 'watermark'), and by explaining the paymentId prerequisite in the context of cost. This goes beyond the schema's dry descriptions.

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

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

The description clearly states the tool's function: removing unwanted objects from images by describing them, with the key differentiator 'no mask needed'. This distinguishes it from siblings like remove_background and edit_image. The verb 'remove' combined with the target resource 'images' makes the purpose 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?

The description provides clear context on when to use the tool: for object removal via natural language, with examples like 'person', 'car', 'watermark'. It also states a critical prerequisite: 'Requires create_payment with toolName='remove_object''. While it doesn't explicitly mention alternatives, the examples and workflow imply appropriate usage.

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

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

With no annotations provided, the description carries full burden. It discloses that the tool sends an email, checks for existing LNURL refunds, and returns the existing LNURL instead of creating duplicates. This level of detail is excellent for an AI agent.

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

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

The description is three sentences with critical information front-loaded. Every sentence adds value: purpose, exclusion criteria, and edge-case handling. No redundancy or wasted words.

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

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

For a tool with no output schema, the description adequately explains the return behavior (duplicate detection and return of existing LNURL). Given the complexity and the sibling tools, this description is complete and leaves no ambiguity about when and how to use the tool.

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

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

Schema coverage is 100% and each parameter has a clear description. The description adds context for why parameters are used (e.g., invoice as refund destination), but does not provide additional semantics beyond what the schema already conveys. 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 purpose: to open a manual 48-hour refund review ticket for failed services (error, timeout, wrong output). It distinguishes this from automatic refunds for metered services, which is crucial for correct tool selection.

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 when to use (service failed) and when not to (unused-minute refunds on metered services). It names the alternative (automatic LNURL-withdraw link) and describes behavior when called incorrectly (detects pending refunds and returns existing LNURL).

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

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

With no annotations provided, the description carries the full burden. It discloses the underlying model (CodeFormer SOTA), adjustable fidelity, background and upscale behavior, auto-upgrades, and payment model. It does not mention rate limits or auth needs (states no API key/signup), but omits output format details.

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

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

The description is front-loaded with the main purpose and then provides structured details (model, fidelity, payment). It is not overly verbose, but each sentence adds information. It could be slightly more concise, but overall well-organized.

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

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

Given no output schema, the description should mention the return format (e.g., base64 image) but does not. It covers key aspects: purpose, cost, payment flow, background/upscale, and model. Missing explicit output description reduces completeness for a 6-parameter tool.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds meaning beyond the schema by explaining fidelity as trade-off between quality and identity preservation, linking background_enhance and face_upsample to overall enhancement, and reflecting paymentId cost context. This adds value.

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

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

The description clearly states the tool restores blurry, damaged, or AI-generated faces to sharp natural quality. It specifies the use of CodeFormer and mentions adjustable fidelity, background enhancement, and upscaling, which distinguishes it from sibling tools like deblur_image or upscale_image.

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 usage context like payment requirements (create_payment with toolName='restore_face') and cost (5 sats per image), but lacks explicit guidance on when to use this tool over alternatives or conditions to avoid. It does not exclude other image restoration 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?

Annotations declare destructiveHint=true, consistent with sending email. The description adds behavioral details: plain text, size limits, cost (200 sats), payment requirement, and no SMTP/verification. It does not cover delivery guarantees or errors, but annotations reduce the burden.

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 relatively concise with front-loaded purpose. Each sentence adds information, though it could be better structured (e.g., separating requirements from capabilities).

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, constraints, cost, and prerequisites, but it does not mention return values or potential errors. Since there is no output schema, the description should explain what the tool returns (e.g., success status). This gap reduces completeness.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining how to obtain the paymentId (via create_payment) and reiterating constraints like max lengths. It also mentions plain text, which is in the schema but confirmed.

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 sends email ('Reach anyone with an email address') and specifies use cases like formal communication, reports, or contacting outside chat. It distinguishes from sibling tools by focusing on email, not SMS or fax.

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 context for when to use the tool (formal communication, reports, external contacts) and mentions prerequisites (requires create_payment). However, it does not explicitly state when to avoid using it or compare to 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?

Discloses modes, language support, rejection behavior, pricing, max pages/size, and payment necessity. Annotations already indicate destructiveHint=true (consumes credit), and description adds context about what gets rejected pre-payment. Could mention retry or status behavior but overall 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?

Description is substantial but front-loaded with use cases. Every sentence adds value (pricing, limitations, mode details). Could be slightly more structured (e.g., bullet points) but is not verbose.

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 7 parameters, complex dual-mode behavior, language support, and pricing details, the description covers all necessary aspects. No output schema exists, but behavior and constraints are fully explained, enabling 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 covers all parameters with descriptions. Description adds value by specifying phone number format (E.164), explaining pages as quantity for create_payment, and clarifying mode differences (pdfUrl vs text). Provides more context than schema alone.

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 uses specific verb 'send' and resource 'fax', lists use cases (loan paperwork, signed contract, booking confirmation), and distinguishes two modes (pdf/text). Clearly differentiates from sibling receive_fax.

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 (need paper trail, worldwide), provides mode selection criteria, lists rejected content (RTL, emoji) before payment, details pricing and prerequisite paymentId, and directs to create_payment for proper invoicing.

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 details critical behaviors: phone format, message length limit with auto-appended disclaimer, international delivery constraints (one-way, no error), and payment requirements. This adds significant value beyond the annotations (openWorldHint, destructiveHint).

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 relatively concise and front-loaded with purpose, but it repeats payment requirements in both the first bullet and later sentences, causing slight 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?

The description lacks information about what the tool returns or how to interpret the result. Without an output schema, the agent needs to know if the call is synchronous or asynchronous and what response to expect.

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?

All three parameters are described in the schema, but the description adds essential context: paymentId must be paid, phoneNumber format and international quirks, message max length with auto-disclaimer. This clarifies usage 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 sends SMS messages for real-world coordination, specifying worldwide reach and speed. However, it does not explicitly differentiate from sibling tools like send_email or send_fax.

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 mentions using when 'real-world coordination' is needed and outlines prerequisites (create_payment). But it does not provide explicit when-not-to-use guidance or compare to 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?

Despite no annotations, the description comprehensively covers behavioral traits: tier-specific character rates, adjustable speed, payment via Bitcoin Lightning, no API key required, and the silent handling of the language parameter on non-OmniVoice tiers. This fully informs the agent of expected behavior.

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

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

The description is well-structured with clear tiers and parameter sections, but it includes an extremely long list of voice descriptions that could be referenced externally. While exhaustive, it slightly compromises conciseness. Still, every sentence adds value given 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 no output schema, the description is remarkably complete. It explains return value (audio URL), payment flow, tier selection, parameter interactions, and exclusion cases. No behavioral aspects are left unexplained, making the tool fully usable by an AI agent.

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

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

Schema coverage is 100%, but the description adds substantial meaning beyond the schema. For the language parameter, it explains tier-dependent behavior. For voice, it provides a complete list with descriptions. For paymentId, it clarifies the requirement. This significantly aids correct parameter selection.

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

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

The description clearly states that the tool converts text to speech, details three distinct tiers with their capabilities, and contrasts with sibling tools like place_call. It uses specific verbs (convert, returns) and resources (audio URL), making the purpose unambiguous.

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

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

The description explicitly lists when not to use the tool (for phone calls) and provides alternative tools (place_call, ai_call, open_voice_bridge). It also advises on tier selection for rare languages, offering clear guidance on choosing between OmniVoice Global, Inworld Premium, and Minimax Studio.

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

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

Despite no annotations, description fully discloses: async processing, polling mechanism, limits (500MB/60min, 13 languages), privacy (ephemeral, never persisted), payment model (Bitcoin Lightning, no signup). 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?

Relatively dense but well-structured: begins with purpose, then details model, capabilities, flow, pricing, privacy. Each sentence adds unique information; no redundancy.

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

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

Covers all major aspects: async flow, payment, polling, limits, privacy, language support. No output schema, but description explains how to retrieve results (polling). Adequate for the complexity.

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

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

Schema coverage is 100% but parameter descriptions are minimal. Description adds value by explaining paymentId requires prior create_payment, language list, and audioBase64 encoding, going beyond 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?

Clearly states 'Transcribe audio to text with timestamps', specifying verb (transcribe), resource (audio), and distinctive output (timestamps). Differentiates from siblings like transcribe_translate (which adds translation).

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

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

Provides explicit async workflow: use create_payment first, poll with check_job_status, then get_job_result. Mentions constraints (size, duration, languages, pricing). Lacks explicit 'do not use when' but implies 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?

Despite no annotations, description discloses async polling, payment requirement, auto-detection, and a warning about language inaccuracies. Covers key behaviors well.

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?

Front-loaded with main purpose, each sentence adds value, though slightly verbose. No redundancy.

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

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

Covers prerequisites, async result handling, pricing comparison, and language limitations. Complete for a complex tool without output schema.

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

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

Schema coverage is 100%, but description adds context: explains paymentId origin, lists allowed source language codes with warning, and clarifies target language formats.

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 clearly states it transcribes and translates audio from 13 source languages to 119 target languages, distinguishes from sibling tools transcribe_audio and translate_text by being a compound endpoint and cheaper.

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

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

Provides clear use cases (WhatsApp voice messages, meeting recordings) and contrasts with separate calls, but lacks explicit when-not-to-use instructions.

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 fully discloses quality tiers (good/fair/unverified/experimental), model used (MADLAD-400), and that response includes the tier. No hidden behaviors.

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 thorough and well-organized, with key information front-loaded. A few minor redundancies (e.g., listing many languages) but generally every sentence adds value.

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

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

Given 3 required parameters and no output schema, the description covers all essential aspects: quality, payment, prerequisites, and fallback tool. No gaps identified.

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?

All three parameters have descriptions in the schema (100% coverage). The description adds value by clarifying text length limit, pricing formula per character, and acceptable language identifiers (codes or English 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 clearly states it translates into rare languages, specifying 452 languages, many not supported by other chatbots. It explicitly distinguishes from mainstream translation tools and provides concrete language examples.

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 recommends using 'translate_text' for mainstream languages (cheaper, more fluent). Describes payment flow via Bitcoin Lightning. States unsupported languages are rejected before payment.

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 fully discloses behavioral traits: model selection (GPT-OSS 120B), auto-detection of source language, privacy policy (no data stored), pricing (1 sat per 1,000 chars), language format support, and a critical warning about sourceLanguage causing silent mistranslation if set incorrectly. This is comprehensive transparency.

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

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

The description is front-loaded with the core purpose and model, followed by key details in a logical order. It is somewhat lengthy due to the language list and pricing details, but every sentence serves a purpose for a tool that requires payment and has many parameters. Could be slightly trimmed but remains clear.

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

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

Given the tool's complexity (5 parameters, payment requirement, 119 languages, no output schema), the description covers essential aspects: how to pay, language formats, auto-detection, and a critical caveat. It does not explicitly state the return value, but for translation it is intuitive. Overall quite 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?

Although schema coverage is 100%, the description adds significant meaning: explains pricing per character, language format options (English names, ISO codes, locale tags), notes that modelId is optional and auto-selected, and warns about the sourceLanguage parameter leading to silent mistranslation if improperly set. This goes well 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 'Translate text across 119 languages with high accuracy,' specifying the verb (translate), resource (text), and scope (119 languages, GPT-OSS 120B model). However, it does not differentiate from sibling tools like transcribe_translate or translate_rare_language, reducing clarity relative to alternatives.

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 extensive details about usage (payment, language codes) but offers no guidance on when to use this tool versus siblings or when not to use it. It does not mention alternatives or conditions for preferring this tool over others.

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

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

With no annotations provided, the description fully discloses behavioral traits: it names the model (Real-ESRGAN), states it recovers real detail (not interpolation), mentions optional face enhancement, describes stable endpoint with automatic upgrades, and lists pricing (5 sats per image, pay-per-request with Lightning, no API key). No contradictions.

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 (~70 words) and front-loaded with the primary action. Every sentence adds value: purpose, technical details, payment requirement, and behavioral notes. No redundancy.

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

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

For a tool with 4 parameters and no output schema, the description covers behavior, prerequisites, pricing, and model information. It does not describe the return format (e.g., base64 image), but given the context, it is reasonably complete.

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

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

Schema coverage is 100%, so the schema already documents all parameters. The description adds marginal value by noting the default scale (4x) and that imageBase64 can be a data URI. For a high-coverage schema, baseline 3 is appropriate.

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

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

The description clearly states the tool upscales images 2x or 4x using neural super-resolution. It distinguishes itself from sibling tools like 'edit_image', 'generate_image', and 'restore_face' by focusing on resolution enhancement via machine learning.

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 requires a prior payment via 'create_payment' with toolName='upscale_image', which is a clear usage prerequisite. However, it does not specify when to use this tool over alternatives like 'edit_image' or 'restore_face', leaving some ambiguity.

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?

Beyond the minimal annotation (openWorldHint: true), the description adds key behaviors: STT is automatically muted during injection, and no additional payment is required (covered by session deposit). These details help the agent understand side effects and costs. It could mention error handling if the session is invalid, but overall it adds meaningful 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?

Four sentences with no wasted words. The first sentence states the primary action, the second explains the two modes, the third covers a behavioral detail (STT muting), and the fourth addresses payment. Every sentence serves a distinct purpose, and the description 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 tool has 6 parameters (all described), no output schema, and a straightforward purpose, the description covers the essential aspects: modes, limitations (encoding), and behavioral context. It could mention asynchronous behavior or success indicators, but the current completeness is high enough for effective use.

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 descriptive parameter comments. The description adds value by explaining the two interaction modes (text vs audio_base64+encoding), noting that mp3/opus are not yet wired (MVP), and clarifying that voiceDescription is free-form. This goes beyond the schema without repeating 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 begins with a clear verb+resource: 'Inject audio into an open Voice Bridge call.' It then details two distinct modes (TTS or audio_base64+encoding), which distinguishes it from sibling tools like text_to_speech (standalone TTS) or open_voice_bridge (session management). The purpose is immediately obvious and specific.

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

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

The description explains when to use this tool (to inject audio into an active call) and mentions that STT is automatically muted, implying appropriate context. It does not explicitly state when not to use it or list alternatives, but the context signals from sibling names and the clear two-mode design provide sufficient guidance. Minor lack of exclusions prevents a 5.

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

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

No annotations provided, so description carries full burden. It discloses cost ('1 sat per vote'), behavior ('multiple votes allowed'), return format ('Returns JSON: { success, slug, newVoteCount }'), and prioritization logic ('Highest-voted services get prioritized'). Could add error handling details, but overall strong.

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

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

Three succinct sentences. First sentence states action and return, second covers cost and allowance, third covers prerequisite and outcome. No fluff, every sentence adds value.

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

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

Given two required params, no enums, no output schema, the description covers all necessary context: payment flow, slug discovery, return structure, and voting rules. It is fully adequate 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 coverage is 100% but description adds context beyond schema: for slug it adds 'from list_planned_services', for paymentId it adds '1 sat, must be paid'. This aids correct usage beyond the schema's basic descriptions.

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

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

Description clearly states 'Vote for a planned service to be built next' with a specific verb (vote) and resource (planned service). It distinguishes from sibling 'list_planned_services' by mentioning it as a prerequisite, and no other sibling tool duplicates this 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?

Explicitly says to 'Call list_planned_services first' for valid slugs and vote counts, and 'Requires create_payment with toolName='vote_on_service''. Provides clear when-to-use and prerequisites.

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