Sats4AI - Bitcoin-Powered AI Tools

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

Discloses key behaviors beyond annotations: auto-retries on voicemail (up to 3 tries), returns full transcript with structured analysis, may return clarification questions, async execution model with polling. Also mentions cost range, language support, and payment method. No contradiction with openWorldHint annotation.

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 thorough but slightly long; however, every sentence adds value. Information is front-loaded with purpose and alternatives, followed by behavioral details, cost, and language support. Well-structured for agent consumption.

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

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

Covers the entire tool lifecycle: payment creation, call initiation, retry behavior, possible pending_confirm state, polling mechanism, and error handling. Even without an output schema, it mentions returned transcript and structured analysis. No gaps given the tool's 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% with descriptions for all 6 parameters. Description adds significant context: explains language guessing logic, specifies payment ID must be paid, gives E.164 format for phone number, and provides duration range. Goes beyond schema to explain parameter interplay.

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 sends an AI voice agent to handle calls, with specific use cases (booking, negotiating, IVR menus). Explicitly differentiates from siblings by naming alternatives (place_call, open_voice_bridge, send_sms) and explaining when not to use each.

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 and when-not-to-use conditions, including prerequisite steps (create_payment with specific parameters). Details the async nature, polling method, and the possibility of returning 'pending_confirm' state requiring confirm_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?

With no annotations, the description carries full burden. It discloses the model used (Qwen VL), cost (21 sats), payment method (Bitcoin Lightning via create_payment), and that no API key is needed. However, it does not describe error handling, timeout behavior, or output format beyond implied text.

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 (4 sentences) and front-loaded with purpose. It efficiently covers the tool's function, model, cost, and prerequisite. No wasted words, but could include a brief note on output type without adding length.

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

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

For a tool with no output schema and 4 parameters, the description covers the core purpose, model, and payment requirement. It is missing details about the response format (e.g., JSON structure) and error scenarios. With zero annotations, more behavioral context would be beneficial.

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% (all 4 parameters documented). The description adds no extra parameter info beyond the schema, except the imageBase64 parameter's warning about PDFs. The modelId parameter description is minimal. Baseline 3 due to high schema coverage.

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

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

The description clearly states the tool analyzes and describes image content, answers visual questions, and extracts information. It mentions the Qwen VL model's capabilities (OCR, chart reading, spatial reasoning). However, it does not explicitly differentiate from siblings like detect_objects or extract_receipt, which have similar but specific purposes.

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

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

The description provides a useful guideline in the imageBase64 parameter description about not using for PDFs (use extract_document instead). However, it lacks explicit when-to-use guidance compared to other image analysis tools. No mention of prerequisites like image format or size limits.

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

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

With no annotations, the description carries full burden. It discloses async nature (returns requestId, poll with check_job_status), resolution options, duration limits, pricing, and payment method. Missing details on rate limits or image size constraints, but still substantial.

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

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

The description is three sentences long, front-loading the purpose and then providing key details. Each sentence adds value with no fluff. Slightly more verbose than necessary but still 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?

The tool is complex (5 params, async, payment, pricing, resolution) and has no output schema. Description covers async polling and payment, but lacks details on response format, error handling, and how to retrieve audio. Some gaps remain for a complex 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% (5 params documented). The description adds value by explaining payment dependency, async polling, and pricing, but introduces confusion by mentioning an optional last frame which is not in 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's purpose: 'Animate a still image into cinematic video with ByteDance Seedance 2.0'. It uses a specific verb ('animate') and resource ('still image'), distinguishing it from siblings like generate_video which creates video from scratch.

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 prerequisites: 'Requires create_payment with toolName="animate_image"' and explains usage: provide prompt, first frame, optionally last frame. It also notes async behavior and polling. However, it doesn't explicitly 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?

The description goes beyond the annotations (readOnlyHint, idempotentHint) to explain that the tool waits, can stream progress, and returns status with timed_out flag after 4 minutes. This adds significant context about the tool's behavior, including error/retry scenarios, without contradicting the 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 and concise, with the core purpose in the first sentence followed by essential details on parameters, streaming, and timeout. Every sentence adds value, and the structure is easy to parse.

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

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

Given the tool has no output schema, the description adequately covers the return behavior: final result on completion, progress notifications when streaming, and IN_PROGRESS status with timed_out after 4 minutes. This is complete for an agent to understand how to use the tool and interpret responses.

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

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

The input schema already provides 100% coverage with descriptions for both parameters. The description adds value by explaining the origin of requestId and the requirement that jobType must match the async tool, and enumerates the valid enum values. This extra context justifies a score above the baseline of 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's purpose: to wait for an async job to finish and return its result in a single call, eliminating manual polling. It specifies the required inputs (requestId + jobType) and explicitly names the async tools that produce these, distinguishing it from sibling tools like 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?

The description provides detailed guidance on when to use this tool, including the streaming behavior (with Accept header), the timeout behavior (up to 4 minutes), and instructions to call again with the same requestId if status is IN_PROGRESS. It also notes that this tool is equivalent to check_job_status + get_job_result combined, helping the agent choose correctly.

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

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

Adds significant behavioral context beyond annotations: free tool, polling behavior, retry prohibition on failure. Annotations already declare idempotentHint=true; no contradiction.

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?

Every sentence adds value, from purpose to return format to usage constraints. Front-loaded with core purpose, logically ordered, and 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 2 required params, no output schema, and 100% schema coverage, the description fully equips an agent to use the tool correctly, including return structure, polling guidance, and error handling.

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 mapping of jobType enum values to specific async tools, which clarifies meaning beyond enum values alone. Could be improved by linking more explicitly to parameter 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?

Clearly states 'Poll the status of an async job' with a specific verb and resource, and explicitly lists async tools that return requestId, distinguishing from synchronous 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 explicit when to use (after async tools), when not to use (synchronous tools), polling interval (every 5-10 seconds), and actions on completion (call get_job_result) or failure (do not retry automatically).

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=true and idempotentHint=true. Description adds crucial behavioral details: free, no cost, invoice expiration (10 min), and the meaning of readyToUse. 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: 4 sentences total, each earning its place. Front-loaded with purpose, followed by return details, usage instruction, and additional notes. 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?

Complete for a simple read-only tool with 1 param and no output schema. Explains return fields, lifecycle (expiry), usage flow, and cost. No gaps given the tool's simplicity.

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

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

Schema covers 100% of parameters and already describes paymentId. Description adds context by linking it to the return of create_payment, which is helpful but not essential 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 checks if a Lightning invoice is paid, explains the return fields (especially readyToUse), and differentiates from create_payment. It's specific and unambiguous.

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

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

Explicitly says to call after create_payment and before the target tool, mentions invoice expiry and that a single check is usually sufficient due to instant wallet payments. Provides clear when-to-use and what-to-do-if-expired guidance.

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

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

With no annotations, the description carries full burden. It discloses high-fidelity reproduction, turbo/HD modes, cost (7500 sats), payment method (Bitcoin Lightning), and no signup required. This sets clear expectations, though it could detail constraints like audio duration limits.

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

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

The description is concise with four sentences that are front-loaded and informative. Every sentence adds value without redundancy or filler.

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

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

For a 4-parameter tool with no output schema, the description covers core functionality, payment requirement, and mentions the reusable voice_id output. It lacks details on return format but is generally 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 baseline is 3. The description adds context for the model parameter (turbo vs HD) but does not elaborate on accuracy or voiceFileUrl. The schema descriptions are sufficiently clear, so the description adds marginal 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 action 'Clone any voice from a single audio sample' and the outcome 'Returns a reusable voice_id for text_to_speech'. It defines the resource (voice) and distinguishes from sibling tools like text_to_speech and transcribe_audio.

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 the prerequisite of calling create_payment and explains the pricing model, but does not explicitly state when to use this tool versus alternatives or provide when-not-to-use scenarios. The context is adequate but lacks explicit exclusion criteria.

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

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

With no annotations, the description fully discloses algorithm (DDColor), cost (5 sats), payment method, model variants, and that it's impossible for LLMs. 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?

Two sentences plus a key requirement, front-loaded with purpose, no filler 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?

Covers purpose, payment flow, algorithm, variants. Minor gap: no mention of output format (e.g., base64 of colorized image), but acceptable given no output schema.

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

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

Schema coverage is 100% and description adds meaning: explains model_size options ('tiny' faster, 'large' best quality), clarifies paymentId prerequisite, and mentions base64 format for image.

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 'Colorize black-and-white or grayscale photos' with a specific verb and resource. It mentions the DDColor algorithm and distinguishes from many image-related 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 context: payment requirement, no signup, prerequisite call to create_payment with specific toolName. Lacks explicit comparison to alternatives like edit_image, but overall helpful.

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 openWorldHint annotation, the description adds key behavioral info: it uses the original payment (no new payment) and returns a call_id for polling. It does not cover error states or side effects, but given minimal annotations, it provides useful 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 sentences, no fluff. Core purpose, prerequisite, payment note, and return value are all front-loaded. Every sentence is essential and 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?

Covers prerequisite, behavior, optional answers, and return value (call_id for polling). Lacks error descriptions or constraints, but given no output schema, this is reasonably complete for a confirmation 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 the description adds meaning: explains that answers are key-value pairs answering push-back questions, and omitting confirms as-is. For sessionId, it specifies source. This adds value 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 the tool's purpose: confirming an AI call after reviewing push-back questions. It specifies the prerequisite (required when ai_call returns state='pending_confirm') and distinguishes from sibling tools like ai_call (initiation) and check_job_status (polling).

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: 'Required when ai_call returns state="pending_confirm".' It also mentions that no new payment is needed, guiding usage. Does not explicitly state when not to use or list alternatives, 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?

No annotations are provided, so the description carries the full burden. It states the conversion engine preserves formatting and quality and returns a download URL, giving moderate behavioral context. However, it omits details like file size limits, processing time, or error behavior that could be important for an 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 five sentences, front-loaded with the core purpose, and each sentence adds distinct information: supported formats, engine quality, output type, cost, and payment requirement. No redundancy or fluff.

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

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

Given 5 parameters, no output schema, and no annotations, the description provides a solid overall picture: purpose, payment flow, and output format. It lacks details on error handling and limits, but for a straightforward conversion tool with a well-known interface, it is largely complete.

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

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

Schema coverage is 100% with all 5 parameters described. The description adds minimal parameter-level insight beyond the schema—it mentions paymentId requirement implicitly via '100 sats' but does not elaborate on fileUrl vs fileBase64 trade-offs. Baseline 3 is appropriate given high coverage.

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

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

The description clearly states the tool converts files between 200+ formats, listing examples across document, image, audio, and video categories. It uses a specific verb-resource pair ('Convert files') and highlights the breadth of supported formats, but does not explicitly differentiate 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 payment model (100 sats per request, Bitcoin Lightning, no account needed) and instructs the user to call create_payment with toolName='convert_file'. It does not provide explicit when-not-to-use guidance or contrast with alternatives, but the usage 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?

No annotations provided. Description discloses cost, temporary URL validity (~1 hour), supported formats, and payment method. Does not explicitly state non-destructive nature, 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 informative but slightly verbose (5 sentences). All sentences add value; could be trimmed slightly but well front-loaded.

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

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

Given no output schema and no annotations, description covers input, output, use cases, alternatives, cost, payment flow, and supported features 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%. Description adds context: paymentId must come from create_payment with specific toolName, format='markdown' for Markdown, and html is HTML or Markdown content.

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

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

Clearly states it converts HTML/Markdown to PDF, specifies output format (JSON with download URL), and distinguishes from sibling 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 describes when to use (invoices, reports), when not to use (existing files -> convert_file), and prerequisites (create_payment with toolName). Also mentions cost and no signup.

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 carries full burden. Discloses invoice expiration (10 minutes), coverage (one call), return JSON format, and pricing logic per parameter. Could mention idempotency or rate limits, but overall 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?

Front-loaded with purpose and flow, then addresses expiration, modelId, and tool-specific params. Lengthy but necessary given 13 parameters and complex dependencies. Every sentence adds value, 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 return format (JSON), typical flow, expiration, parameter dependencies, pricing, and error handling. With no output schema, return format is explained. For a complex 13-param tool with no annotations, description is exceptionally 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%, baseline 3. Description adds significant meaning beyond schema: explains pricing functions (e.g., text_to_speech per-character, durationMinutes at 10 sats/min), defaults, tool-specific resolution meaning, and that generate_audio is free. Goes well beyond brief 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?

Clearly states it creates a Lightning invoice for one AI service call. Differentiates from siblings by focusing on payment creation. Verb 'create' + resource 'Lightning invoice' + purpose 'pay for one AI service call' is specific and distinct.

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

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

Provides extensive guidance: typical flow (list_models → create_payment → check_payment_status → call tool), each payment covers exactly one call, explains when to omit modelId, and lists required extra params per tool with pricing dependencies. Also explains error handling for missing params.

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

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

With no annotations, the description carries full burden. It discloses cost (20 sats), processing time (~2 min), payment method (Bitcoin Lightning), and prerequisite (create_payment). Does not mention file size limits or invalid image handling, but overall thorough.

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-4 sentences), front-loaded with the main purpose, and each sentence provides necessary context without redundancy. Highly efficient.

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

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

Given 3 parameters, no output schema, and a payment workflow, the description covers the core usage, cost, timing, and dependency on create_payment. Missing output format details, but acceptable for a processing tool with no structured output.

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 paymentId must be paid, specifying task_type defaults ('Image Debluring (GoPro)'), and clarifying the three options. This goes beyond the schema's enum 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 recovers detail from camera-shake and accidental motion blur, names the model (NAFNet), and lists both effective and ineffective scenarios, distinguishing it from sibling tools like 'upscale_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 states when to use (handheld shake, bumped camera, whole-frame uniform blur) and when not to use (intentional panning, bokeh, artistic motion). Also mentions support for denoising and payment requirements, providing clear alternatives and prerequisites.

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

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

No annotations are provided, so the description carries the full burden. It discloses the payment mechanism (Bitcoin Lightning, no signup), the required pre-step (create_payment), and the output format (label and boolean). However, it does not mention potential latency, timeouts, or error handling beyond payment validity. Overall, it adds substantial behavioral context.

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

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

The description is a single paragraph but is well-structured: it leads with the core function, then performance claim, then output, then use case, then pricing/payment. Each sentence adds value without redundancy. Minor improvement could be using bullet points for readability, but it's concise and informative as is.

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 classification tool with two parameters and no output schema, the description fully explains the return values (label and is_nsfw boolean), the payment requirement, and the input format. It provides all necessary context for an agent to invoke the tool correctly, given the tool's simplicity.

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

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

Schema coverage is 100% with both parameters described. The description enriches the parameters by specifying that paymentId must be a paid and valid ID (via create_payment) and that imageBase64 must be a Base64 string of specific formats (PNG, JPEG, WEBP) or data URI. This adds meaningful usage guidance beyond the schema's type and required flags.

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 classifies image safety into three categories (normal/suggestive/explicit) and returns a classification label and boolean flag. It distinctly distinguishes itself as NSFW detection from Falcons.ai, with a specific verb 'detect' and resource 'NSFW', making its purpose immediately clear.

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

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

The description positions the tool as essential for content moderation and highlights it is cheaper and faster than using an LLM. While it provides context for when to use it, it lacks explicit guidance on when not to use it or alternative sibling tools like 'analyze_image' or 'detect_objects'. The mention of payment flow adds practical usage context.

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

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

No annotations are provided, so the description carries the full burden. It discloses the payment requirement, the underlying model (Grounding DINO), and the structured output format. It does not describe side effects or limits beyond the per-image cost.

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

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

The description is three sentences, front-loaded with the core purpose. It is efficient but could be slightly tighter by removing 'Structured pixel data agents can't get from vision LLMs' if redundant. Still, 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?

Given no output schema, the description adequately explains the output (bounding boxes and scores). It covers the payment workflow and parameter roles. A bit more on image limitations or error cases would improve 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%, and the description adds context for the 'query' parameter (comma-separated object names) and explains the paymentId requirement. It also mentions default thresholds, which are already in the schema. Overall, adds meaningful value beyond the schema.

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

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

The description clearly states the tool detects and locates objects in an image by name using Grounding DINO, and provides bounding box coordinates and confidence scores. This distinguishes it from siblings like remove_object or analyze_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 mentions it requires a payment via create_payment and costs 5 sats per image, and contrasts with vision LLMs. However, it does not explicitly specify when to use this tool versus alternatives, or provide exclusion criteria.

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

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

With no annotations, the description covers return format (JSON with image URL), resolution-tiered pricing, and payment mechanism. However, it omits details on error handling, size limits, or processing time, which would be helpful.

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

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

Three sentences, each delivering distinct, essential information: purpose/capabilities, model details, and pricing/workflow. 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?

No output schema exists, so description should clarify return structure beyond 'image URL'. Also lacks details on error states or payment failure handling. Given tool complexity (6 params, payment integration), completeness is adequate but not thorough.

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 param descriptions already exist. The description adds value by noting paymentId must be paid and linking resolution to cost, but largely reiterates schema info. 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?

Description clearly states the tool edits images via natural language, lists specific capabilities (object addition/removal, style transfer, inpainting), and names the model. This distinguishes it from sibling image tools like generate_image or remove_background.

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 prerequisite (create_payment with specific parameters) and payment flow via Bitcoin Lightning. Implicitly differentiates from alternative tools by focusing on editing rather than generation or analysis, though no explicit when-not-to-use is given.

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 key behaviors: ends call, finalizes billing, returns refund and transcript. However, it does not mention side effects like irreversibility or any auth requirements.

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

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

Two concise sentences with no fluff. The first sentence captures the main action and outputs, the second adds a convenience detail.

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

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

Given no output schema, the description adequately mentions the returns (refund link and transcript). It covers the tool's purpose and key outputs, though could mention error states or default behavior.

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

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

Schema coverage is 100% with good description for sessionId. The description does not add further meaning 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 action ('Hang up'), the resource ('Voice Bridge call'), and the outputs (finalize billing, refund link, transcript). It distinguishes from sibling tools like open_voice_bridge and poll_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?

Usage is implied by the context (takes sessionId from open_voice_bridge), but there is no explicit guidance on when to use versus alternatives or when not to use it (e.g., if the call already ended).

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 behavior (returns jobId, poll 5-60+ min), three voice tiers with char/sat limits, min 500 sats, optional translation cost, and chapter selection auto-drop behavior. No annotations, so description carries full burden and does it 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?

Description is fairly long but well-organized, front-loading the main purpose and then details. Every sentence adds value; could be slightly more terse but no 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?

Given 9 parameters, no output schema, and complex behavior (async, multiple tiers, translation, chapter selection), the description covers return format (jobId), polling instructions, payment requirements, and file format detection via fileName. Sufficient 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 significant context: explains voice tiers in detail (including rankings and character limits), clarifies language parameter behavior (only affects chapter titles on default tier), describes translateToLanguage accepted formats, and warns about selectedChapterIndices auto-dropping short chapters.

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 it converts EPUB/PDF/TXT to audiobooks with chapter detection, multi-voice narration, and optional translation. Distinguishes from siblings like text_to_speech and convert_file by focusing on full book conversion.

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

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

Explicitly explains when to use: for converting books to audiobooks. Mentions it's a single payment with full outcome, async polling, and prerequisites like create_payment. Provides clear context without needing exclusions.

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

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

No annotations provided, so description carries full burden. Discloses behavior: uses Mistral OCR, handles complex layouts, tables, handwriting, multi-column, math notation, preserves hierarchy, costs 10 sats/page, requires payment via create_payment. 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?

Approximately 5 sentences, front-loaded with main purpose. Each sentence adds unique information (OCR capabilities, cost, payment process). No redundancy or fluff.

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

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

Complete for an extraction tool with 3 parameters, no output schema. Covers capability, cost, payment prerequisite. Addresses multi-page PDF handling via create_payment with quantity.

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. Description adds value by explaining that paymentId must be paid and documentBase64 is base64 encoded, and mentions optional modelId with guidance to omit for default. Slightly above 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?

Clearly states 'Extract text from PDFs and images as clean Markdown.' Specifies the resource (PDFs/images) and action (extract text). Distinguishes from siblings by mentioning OCR handling of complex layouts, tables, handwriting, etc. and Markdown 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?

Provides clear usage context: pay per request with Bitcoin Lightning, no API key needed, requires create_payment with toolName='extract_document' and quantity=pageCount. Lacks explicit when-not-to-use or alternatives, but given sibling tools, the intended use case 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?

No annotations provided; description fully carries burden. Discloses dual-model pipeline, handles crumpled/faded/multi-page, pricing (50 sats/page), pay-per-request, no signup, and fabricated output for non-receipts.

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

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

Two concise sentences plus a note in parameter description. Front-loaded with purpose, then details, no redundant information.

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

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

Given 2 parameters, no output schema, no annotations, the description covers purpose, usage, behavior, parameters, and warnings. No apparent gaps for this complexity level.

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 both parameters (100%). Description adds critical warning about accepting non-receipts and potential fabricated output, enhancing understanding 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 verb 'Extract' and resource 'receipts, invoices, and financial documents'. Distinguishes from sibling 'extract_document' by specifying focus on receipts and dual-model pipeline (Mistral OCR + Kimi K2.5).

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

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

Provides payment prerequisite ('Requires create_payment with toolName...') and warns about non-receipt inputs. Lacks explicit when-not to use or alternatives, but context is clear given 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 covers async behavior (polling), payment requirement, model used (Hunyuan3D), and no API key needed. It could mention error handling for invalid input.

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

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

Three concise sentences, front-loaded with the main action, each adding essential info without fluff.

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

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

For a tool with 4 params, no output schema, and no annotations, the description covers payment, async, input modes. It mentions polling with check_job_status but does not specify what the result of that poll contains, though that is a different 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%, so baseline is 3. The description reinforces mutual exclusivity of prompt and imageBase64 but adds no new meaning beyond 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 it 'Generate a textured 3D GLB model' and specifies the two input modes (photo or text prompt), distinguishing it from other generate tools listed in 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 provides explicit guidance on providing exactly one input (photo or prompt) and mentions async polling and payment requirements. However, it does not explicitly exclude alternative scenarios or tools.

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

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

No annotations are provided, so the description carries full burden. It discloses return format (JSON with URL), model upgrade policy, payment mechanism, and img2img capability. Lacks error handling or rate limit info, but is reasonably transparent.

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

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

The description is compact with four sentences, each providing essential information without redundancy. The main action is front-loaded, and model details are efficiently listed.

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 4 params, no output schema, and no annotations, the description covers key aspects: models, costs, payment, img2img, and automatic upgrades. It could mention expected output structure or error cases, but is largely complete.

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

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

Schema coverage is 100%, and the description adds meaning: it explains modelId choices (Grok, Seedream, Nano Banana with costs) and clarifies that imageBase64 enables img2img. It also notes that paymentId must be paid, which is not in the schema description.

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

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

The description begins with 'Generate an image from a text prompt,' clearly stating the verb (generate) and resource (image). It distinguishes from sibling tools like animate_image and upscale_image by specifying the output format and model options.

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: lists models with costs, mentions img2img, and explains payment requirement with explicit reference to create_payment. However, it does not explicitly state when to prefer this tool over siblings like generate_video or text_to_speech.

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 exist, but the description discloses key behaviors: uses Music-2.6 model, returns MP3 URL, costs 300 sats, requires prepaid payment via Bitcoin Lightning. It does not mention error handling or rate limits, but covers essential 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?

Four sentences front-load the purpose and key features, then cover pricing and payment flow. No wasted words; efficient and 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?

The description covers purpose, model, output format, prerequisites, and cost. Missing error handling or async details, but for a direct generation tool with 9 parameters and no output schema, it is fairly complete.

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

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

Schema coverage is 100% with good descriptions. The description paraphrases some parameters (e.g., 'Specify BPM, key, genre, mood in prompt') but adds no new meaning 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 generates full songs with natural AI vocals, BPM/key control, and section tags. It distinguishes from sibling tools like text_to_speech by specifying song generation with vocal and arrangement capabilities.

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 tells when to use (specify BPM, key, genre, mood) and requires a payment step, but does not compare to alternatives or state when not to use the tool. Usage context is implied, not explicit.

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

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

With no annotations, description carries full burden. Discloses per-character pricing, model details, automatic upgrades, file/vision support, and payment requirements. Lacks failure modes or rate limits but is otherwise thorough.

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 purpose and key details; packed with info but slightly long. Could benefit from more structured formatting (e.g., bullet points) but remains clear and efficient.

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

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

Given 8 parameters, no output schema, and moderate complexity, description covers core usage, model options, prerequisites (payment), and special features like vision. Lacks output format info but sufficient for agent invocation.

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

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

Schema coverage is 100% so baseline is 3. Description adds context: explains model selection (default best), fileContext/imageBase64 usage for Q&A/vision, and paymentId role. Enhances schema 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?

Specifically states 'Generate text using frontier AI language models' and lists distinct models with capabilities (document Q&A, vision), clearly differentiating from siblings like generate_image or transcribe_audio.

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_text' and exact prompt, and mentions no API key needed. Provides clear usage context but doesn't explicitly exclude scenarios or compare with siblings beyond listing features.

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 covers key behaviors: async polling, pricing (BTC-pegged, per second by resolution), and the no-signup requirement. It details the model and resolution options. It does not mention rate limits or error behavior, but the main behavioral traits are transparent.

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

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

The description is remarkably concise—only four sentences—yet covers purpose, model, workflow, pricing, and prerequisites. It is front-loaded with the core action and efficiently structured without redundancy.

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

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

For a tool with no output schema, the description adequately explains the return (requestId) and the polling mechanism via check_job_status. It also covers pricing and payment flow. Missing details like error handling or result format are partially offset by the sibling tool check_job_status, but a bit more could be added.

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

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

The input schema covers 100% of parameters, so baseline is 3. The description adds value by explaining the payment relationship, noting that modelId is optional, clarifying resolution defaults and legacy mapping, and stating that native audio is free. This extra context 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 clearly states 'Generate cinematic video from a text prompt', which is a specific verb-resource pair. It distinguishes from sibling tools like generate_image and generate_text by specifying video generation and naming the ByteDance Seedance 2.0 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?

The description explains the async workflow ('returns requestId, poll with check_job_status') and the prerequisite payment step ('Requires create_payment...'). While it does not explicitly list when not to use this tool, the workflow guidance is clear and 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?

Annotations already declare readOnlyHint=true and idempotentHint=true. Description adds 'No payment required, no side effects' and specifies return format { amount_sats, breakdown, currency }, reinforcing safe behavior beyond annotations. 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?

Three sentences, front-loaded with core purpose, then usage context, then examples and return format. Every sentence adds value with no redundancy.

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

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

Given 6 optional parameters and no output schema, the description covers purpose, usage guidance, example invocations, return format, and special behavior (listing all services). 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% with individual parameter descriptions. The description adds practical examples (e.g., service=text-to-speech&chars=1500) and explains that omitting service lists all services, providing usage patterns 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 'Get an exact sat cost quote for a service BEFORE creating a payment', specifying the verb 'get' and resource 'cost quote'. It distinguishes itself from sibling tools like create_payment and get_model_pricing by emphasizing 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', provides example parameter combinations, and notes that omitting params lists all services. This gives clear when-to-use context and 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 indicate readOnlyHint and idempotentHint. The description adds value by specifying the returned data is a 'machine-readable catalog' with examples, and clarifies no payment is needed. This enhances transparency 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?

Two sentences, no wasted words. The first sentence front-loads the purpose with examples, the second gives usage advice and a behavioral note. Highly concise and 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 no output schema, the description provides enough context: purpose, usage guidance, behavioral note (no payment). The tool is simple with no parameters, so completeness is high given 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?

With zero parameters, the schema description coverage is trivially 100%. The description does not add parameter-specific info, but none is needed. Baseline 4 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 'Get the machine-readable catalog of all error codes this API can return', specifying the verb and resource. It distinguishes itself from sibling tools by providing a unique function not covered by any other sibling.

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

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

The description provides explicit guidance: 'Agents should branch on error_code rather than parsing free-text messages.' It also notes 'No payment required,' clarifying when to use the tool. While no alternatives are mentioned, none exist among siblings.

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 annotations (readOnlyHint, idempotentHint), the description details temporary URLs (~1 hour, download immediately), free usage, and return shape per jobType, providing full behavioral context.

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

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

Every sentence earns its place. Front-loaded with main purpose, followed by usage condition, return shapes, URL expiry, free note, and do-not-use note. Compact yet comprehensive.

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

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

Without output schema, the description compensates by detailing return shapes for each jobType and covering error conditions. Sibling tools list is large, but the description contextualizes usage via jobType mapping.

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% already, and the description adds significant meaning: jobType mapping to async tools, requestId provenance, and jobType enum values explained. Adds value beyond the schema.

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

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

The description clearly states 'Retrieve the final output of a completed async job', providing a specific verb and resource. It distinguishes from sibling tools like check_job_status and synchronous tools.

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

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

Explicitly instructs to call only after check_job_status returns 'completed', warns that calling on non-completed jobs returns an error, and advises against using for synchronous 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 already declare readOnlyHint=true and idempotentHint=true, so the description does not need to restate those. The description adds the behavioral note 'No payment required,' which is helpful. However, it lacks details on error handling or return format, so it adds moderate value 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?

Two short sentences, no wasted words. The first sentence immediately states the purpose, and the second adds a key behavioral note. Ideal 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 simplicity (single parameter, no output schema), the description covers the essential purpose and a key behavioral trait (no payment). It does not explain the return format or error conditions, but the context is largely complete for a straightforward lookup tool.

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

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

The input schema has 100% coverage, with 'modelId' described as 'The AI model database ID'. The description repeats that the ID is for specifying a model, but adds no new meaning. Baseline 3 is appropriate since schema coverage is high and description does not enrich parameter semantics.

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

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

The description clearly states the action ('Get pricing') and the resource ('a specific model by ID'), with a specific verb and resource. It distinguishes itself from siblings like 'list_models' (which lists models) and 'get_cost_estimate' (which estimates cost for a call) by focusing on pricing for a single model by ID.

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 no guidance on when to use this tool versus alternatives such as 'get_cost_estimate' or 'list_models'. It does not mention any preconditions, exclusions, or hints that could help an agent decide between 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 already provide readOnlyHint and idempotentHint. The description adds the return format (JSON array with fields), confirms idempotence and free cost, and elaborates on default model behavior, going 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?

Every sentence adds value. The description is front-loaded with purpose, then provides usage, return format, and safety info. No waste, highly efficient.

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

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

Despite lacking an output schema, the description fully defines the return structure and explains key behaviors (free, idempotent, default model usage). It covers all necessary context for an AI agent to use the tool correctly.

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

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

Schema description coverage is 100%, and the description adds only minor context about filtering (category matches tool names). The schema already describes the parameter adequately, so 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 it discovers AI models with details like numeric IDs, tier labels, capabilities, and pricing. It specifies the use case before create_payment, distinguishing it from other tools.

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

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

Explicitly says to call before create_payment, explains filtering by category, and notes it's free and idempotent. Provides clear 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 note readOnlyHint and idempotentHint. The description adds the exact return format (JSON array sorted by votes) and confirms free usage, providing additional 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?

Every sentence earns its place: states purpose, gives output format, provides usage context, and confirms safety. 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?

Despite no output schema, the description fully specifies the return fields, sort order, and usage suggestions. It is complete for a simple list tool with no 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?

No parameters exist, so schema coverage is 100%. The description adds meaning about what the tool returns, meeting the baseline for zero parameters.

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

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

The description clearly states the tool lists planned services with vote counts, specifies the output format, and distinguishes from the sibling tool vote_on_service by referencing slug usage.

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 (discovery), notes no payment required, and instructs to use slugs with vote_on_service for voting. Also states it is safe to call repeatedly.

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 most behavioral aspects: preserves elements, returns temporary URL, cost, no account needed. However, does not mention error handling or invalid input scenarios. With no annotations, this is a minor gap.

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

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

While the description is fairly long, each sentence adds distinct value. It is well-structured, starting with the core action and followed by details. Could be slightly more terse.

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, requirements, alternatives, cost, and output format. No output schema exists, so the description explains the return value. Adequate given the tool's simplicity.

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

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

Schema covers 100% of parameters. Description adds context: files are base64-encoded, paymentId requires a paid payment, and references create_payment. Enhances understanding 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 explicitly states 'Merge multiple PDF files into a single document' and highlights key features like preserving bookmarks, links, and formatting. It also distinguishes from sibling tool convert_file, making the purpose clear.

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

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

Provides explicit when-to-use guidance: 'Use convert_file instead if you need format conversion'. Also details requirements (minimum 2 files, payment via create_payment) and constraints (concatenation order, time-limited URL).

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 openWorldHint annotation, description discloses extensive behavioral details: lifecycle (speak, poll, end), privacy (in-memory, 30min GC, no persistence), payment via Lightning, refund via LNURL-withdraw, and session ownership. 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?

Description is long but well-structured: front-loaded with purpose, then use cases, alternatives, privacy, payment. Each sentence adds unique value, though some redundancy with schema exists.

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 lifecycle, payment, privacy, and sibling differentiation comprehensively. Lacks explicit mention of return value (e.g., session ID), but implied by subsequent tool references. Overall very complete for a complex tool with no output schema.

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

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

Schema coverage is 100% with good parameter descriptions. Description adds value by explaining deposit rates (10 sats/min US, etc.) and refund flow, plus context on codec and language defaults, which are not 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?

Description clearly states 'Open a Voice Bridge session: a live phone call where YOUR LLM is the brain.' It uses a specific verb and resource, and distinguishes from siblings like ai_call, place_call, and companion tools.

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

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

Explicitly provides 'Use this when...' and 'When NOT to use:' sections with specific alternatives (ai_call, place_call), covering privacy and payment context.

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

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

With only openWorldHint as annotation, the description adds significant behavioral context: it explains the payment method (Bitcoin Lightning, no KYC), the dependency on create_payment, and the OR requirement between message and audioUrl. This goes well beyond the minimal annotation.

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

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

The description is reasonably concise, front-loading the main action and use cases, then adding payment details. It could be slightly more compact, but no sentences are wasted.

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

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

For a tool with 5 parameters and no output schema, the description covers core functionality and prerequisites but lacks details on call outcomes, cost, or limitations (e.g., call duration, geographic restrictions). It provides adequate but not comprehensive context.

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

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

Schema coverage is 100% with descriptions for all 5 parameters. The description does not add significant new parameter-level information beyond what the schema already provides. It restates the OR relationship and mentions the phone number format, but this is already in the schema.

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

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

The description clearly states it places an automated phone call to deliver a spoken message or play audio. It specifies the resource (phone call) and verb (place), and distinguishes from sibling tools by emphasizing physical phone calls, but does not explicitly contrast with tools like 'ai_call' or '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?

The description provides usage context (notifying humans, alerts, offline reach) and mentions the payment prerequisite, but lacks explicit guidance on when to use this tool over alternatives. No sibling comparisons are made.

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 return types (partial + final transcripts + system events), polling behavior, and cost implication. Does not mention error scenarios for closed calls, but overall informative.

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, each essential: describing function, return content, and usage advice. No fluff, front-loaded with core action.

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, return type, polling loop, and cost. No output schema, but return description is adequate. Missing explicit format details, but sufficient for a low-complexity 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 good descriptions. Description adds minimal nuance ('since the last cursor', 'from open_voice_bridge'), not significantly 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 fetches new transcript events from an open Voice Bridge call, using a cursor. It specifies the resource (transcript events) and action (fetch/poll), distinguishing it from siblings like open_voice_bridge, 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?

Provides explicit polling guidance ('~500ms-1s') and notes 'No additional payment'. Lacks explicit when-not-to-use or alternatives, but the context is clear enough for correct selection.

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

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

Discloses no-refund policy, optional OCR with partial refund on failure, and webhook behavior. Does not explicitly address openWorldHint annotation, 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?

Front-loaded with purpose; every sentence adds value, though slightly long. Could be more structured with bullet points.

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 delivery mechanism, optional features, refund policy, and payment. Lacks webhook payload details but adequate given no output schema.

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

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

Adds meaning beyond schema: explains last-10-digit matching for fromNumber, callback webhook HMAC signing, OCR cost and refund, and payment method.

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 'open a 24h receive window' and the resource 'our shared number', making it distinct from sibling send_fax and other communication tools.

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

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

Explicit scenarios are given ('bank confirmation, court filing, signed document'), but no explicit exclusions or alternatives among siblings are mentioned.

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

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

Discloses model (BiRefNet), capabilities (hair, fur, glass, complex edges), stability, automatic upgrades, cost, and payment method. No annotations provided, so description fully covers 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?

Description is fairly concise with 6 sentences, each adding value (purpose, model, handling, stability, cost, prerequisite). Slightly verbose 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?

For a tool with 2 parameters and no output schema, the description covers input constraints, model details, output format (transparent PNG), cost, and prerequisite. Fully adequate for agent understanding.

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

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

Schema coverage is 100% and both parameters are described adequately in the schema. The description adds no additional meaning to the parameters, so baseline score of 3 is appropriate.

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

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

Clearly states the verb 'remove' and resource 'background from any image' with a specific outcome 'returning transparent PNG'. Distinct from siblings like 'remove_object' and '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 details the prerequisite payment process: 'Requires create_payment with toolName='remove_background''. Provides context like pay-per-request and no signup, but no explicit 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 discloses use of Grounding DINO and Bria Eraser, cost of 15 sats, pay-per-request with Bitcoin Lightning, no API key/signup needed, and requirement for create_payment. However, it doesn't mention image limitations or response format.

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 plus a payment instruction. It is concise but packs necessary details. Could be slightly tighter, but overall well-structured and 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?

Tool has 5 parameters but no output schema. The description does not mention what the tool returns (likely base64 image) or if there is a job ID. Error handling and rate limits are absent. Given the complexity, more detail on return value and potential errors would be beneficial.

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 value by giving examples for 'query', stating default thresholds of 0.25, and explaining that paymentId must be paid. This supplements 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 'Remove unwanted objects from images' with specific verb and resource. Examples like 'person', 'car', 'watermark' illustrate usage. It distinguishes from sibling tools like 'remove_background' by specifying text-based removal without masks.

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 when to use: 'just describe what to remove', and mentions no mask needed. It also explains pricing and payment flow. However, it does not explicitly state when not to use it (e.g., for complex edits) or compare with alternatives like 'edit_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 the full burden. It discloses that the tool sends an email to the operator, has a 48-hour review period, and detects pending LNURL refunds to avoid duplicates, offering thorough behavioral context.

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

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

The description is concise and front-loaded with the main purpose in the first sentence. The remaining sentences add crucial usage guidelines and behavioral quirks without redundancy, but could be slightly more 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?

Given no output schema and no annotations, the description provides comprehensive context: purpose, usage boundaries, alternative options, and unexpected behavior (duplicate detection). It fully equips the agent to use the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters fully. The description does not add new parameter-level meaning beyond what the schema provides, thus baseline score of 3 is appropriate.

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

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

The description clearly states the tool opens a manual 48-hour refund review ticket for failed services, specifying the action and resource. It distinguishes from metered service refunds, providing clarity on scope.

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

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

Explicitly states when to use (for failed services with error/timeout/wrong output) and when not to use (unused-minute refunds on metered services). Provides clear alternative: the LNURL withdraw link from the service's response, and explains duplicate detection behavior.

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?

Without annotations, the description carries full burden. It discloses the underlying model (CodeFormer), adjustable fidelity, background enhancement, upsampling, stability, automatic upgrades, pricing, and payment process. This is 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 eight sentences, all adding value. It front-loads the main purpose and efficiently covers multiple aspects 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 no output schema and no annotations, the description covers purpose, usage, pricing, and payment. It lacks details on return format or limitations (e.g., max image size) but is sufficient for a paid 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%, so baseline is 3. The description mentions fidelity and enhancements but does not add new parameter meaning beyond the schema.

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

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

The description specifies 'restore blurry, damaged, or AI-generated faces to sharp, natural quality,' using a clear verb and resource. It distinguishes from siblings like deblur_image and upscale_image by focusing on faces.

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 requirement and fidelity adjustment. It implies use for face restoration but does not explicitly state when to avoid it or compare with alternatives. Sibling context is provided but not leveraged.

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?

Explicitly discloses limitations (plain text only, 10k chars body, 200 chars subject), cost (200 sats), payment method (Bitcoin Lightning), and prerequisite (create_payment). Also states no API key/signup needed. This exceeds annotation minimality.

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 a single paragraph with efficient sentences. It could be better structured with bullet points, but it is not verbose and information is relevant.

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 5 parameters, no output schema, and prerequisite payment, the description covers input constraints, cost, and usage context. Missing return value information but acceptable given no output schema.

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

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

Schema already covers all parameters (100%). Description adds value by summarizing max lengths for subject and body, and clarifying paymentId must be paid. However, it doesn't detail each param 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 tool sends emails to any address, with specific use cases like formal communication and contacting people outside chat, distinguishing it from siblings like 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?

Describes when to use (formal communication, reports, external contacts), notes no SMTP/domain setup needed, and mentions payment requirement. Lacks explicit when-not-to-use, but the constraints (plain text, limits) imply 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?

The description discloses critical behavioral traits beyond the sparse annotations: pricing (500 sats for up to 10 pages, +50 per additional page), limits (max 350 pages/50 MB), modes (pdf/text), cover page behavior, and payment dependency (Bitcoin Lightning). No contradictions with the openWorldHint annotation.

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, well-structured paragraph that front-loads the purpose and examples. Every sentence adds value—pricing, limits, mode details, payment linkage—with no redundancy or unnecessary text.

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

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

Given the tool's complexity (7 parameters, no output schema), the description fully covers the end-to-end workflow: create payment, choose mode, provide details, and send. It addresses pricing, constraints, and mode switching, leaving no obvious 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%, but the description adds significant meaning: it explains how 'pages' relates to payment ('Pass 'pages' to create_payment as 'quantity''), clarifies mode options (pdf vs text with details), and introduces the cover page concept. This goes beyond what the schema 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 starts with a clear purpose statement: 'send a fax to any number worldwide' with concrete examples (loan paperwork, signed contract, booking confirmation). It distinguishes the tool from siblings by focusing on fax, which is unique among sibling tools like send_email or 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?

The description provides context for when to use the tool ('when your task requires a paper-trail') and explains the two modes. However, it does not explicitly state when not to use it or mention alternatives, leaving some room for 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?

The description discloses key behaviors: fast delivery, no phone plan needed, Bitcoin Lightning payment, and importantly, the one-way nature for international numbers with no error returned. This goes beyond the openWorldHint annotation. However, it omits potential limits or fees.

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 primary action. Every sentence adds value without redundancy, making it efficient for an AI agent to parse.

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

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

Given no output schema, the description covers prerequisites, usage, and behavioral nuances. However, it does not clarify what the agent can expect after sending (e.g., success indication, receipt). Slightly incomplete for a complete picture.

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, the description adds meaningful context: message max 126 chars with disclaimer auto-appended, phone number must be E.164 format, and international delivery behavior. This exceeds what the schema 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 it sends SMS messages for real-world coordination to any phone number worldwide. It does not explicitly contrast with sibling tools like send_email or place_call, but the purpose is specific and unambiguous.

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

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

The description explains when to use the tool ('when your task requires real-world coordination') and details prerequisites (create_payment with matching parameters). It does not provide explicit when-not-to-use or alternatives, 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 provided, the description fully covers behavioral traits: rate limits (100/50/10 chars/sat), voice cloning capability, adjustable speed (0.5-2.0x), return type (audio URL), payment method (Bitcoin Lightning, no API key), and that language parameter is silently ignored on non-OmniVoice tiers. No contradictions with annotations since none exist.

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 key information (tiers, rates, when not to use) but includes an extensive voice catalog that significantly lengthens it. While necessary for voice selection, it could potentially link to a separate resource. The structure uses clear headings and is well-organized, so it earns a high score despite length.

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

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

Despite lacking an output schema, the description covers all essential aspects: input parameters, tiers, language support, voice options, speed control, payment, and usage boundaries. It is complete enough for an agent to select and invoke the tool correctly without needing additional context.

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

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

Schema coverage is 100%, but the description adds critical context: explains that 'language' only works on OmniVoice tier, provides a massive voice catalog inline with gender/age/style descriptions, clarifies modelId tiers and their features, and notes that paymentId must be paid. This goes far beyond the schema's basic type/description.

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

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

The description clearly states this is a text-to-speech tool with three distinct tiers (OmniVoice Global, Inworld Premium, Minimax Studio), each with specific capabilities like voice cloning and language support. It explicitly distinguishes from sibling tools (place_call, ai_call, open_voice_bridge) by stating when not to use this tool, making the purpose unmistakable.

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

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

The description provides explicit guidance on when to use each tier, including character limits and language coverage. It includes a clear 'When NOT to use' section directing to phone call tools for broadcast and AI voice agents. It also gives specific recommendations for rare/underserved languages (Yoruba, Twi, etc.) and which tier to select via the language parameter.

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, but the description fully discloses async behavior, ephemeral privacy, cost (10 sats/min), file limit (500MB/60min), language support, and payment flow. No ambiguity or contradiction.

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?

Packed with information in a structured, front-loaded manner. Some redundancy (e.g., repeating 'no API key needed') but overall efficient.

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

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

Completely covers the tool's complexity: async flow, limits, languages, cost, privacy, and payment integration. No output schema, but return value (requestId) and polling are clearly explained.

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 has 100% coverage and description adds context (e.g., paymentId must be paid, language list), but does not fundamentally expand on schema definitions. Adequate but not exceptional.

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 the core function. Differentiates from sibling tools like transcribe_translate and text_to_speech by focusing on pure transcription.

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 async workflow with polling via check_job_status and get_job_result, and payment requirement via create_payment. Does not explicitly state 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?

Discloses async behavior, flat pricing model, Bitcoin Lightning payment, no API key needed, source language auto-detection with a warning about garbled transcripts, and the need for create_payment. No annotations provided, so description fully covers 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 reasonably concise with 6 sentences, front-loads core purpose, and each sentence adds essential information. Slightly long but well-structured with no redundant 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?

Covers all relevant contextual details: purpose, parameters payment integration, async polling, cost comparison, language support, and warnings. No output schema, but return value (requestId) is mentioned. Completely 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?

All 4 parameters are described in schema (100% coverage), and the description adds critical context: for sourceLanguage it lists the 13 languages and warns about wrong hints; for targetLanguage it gives examples; for paymentId it states it must be paid. Schema coverage is high, but description still 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 it is a compound endpoint that transcribes and translates audio, listing the supported languages and explicitly distinguishing itself from sibling tools transcribe_audio and translate_text as 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 specific use cases (WhatsApp voice messages, meeting recordings), compares cost with alternatives, explains async polling with check_job_status, and mentions prerequisites like create_payment and required 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?

With no annotations, the description fully carries the burden. It discloses the model (Qwen3-32B), auto-detection behavior, privacy (no data stored), pricing structure, payment flow, and a critical note about sourceLanguage validation (accepts any valid language, not checking actual content). This is highly transparent.

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

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

The description is verbose, repeating the full list of 119 languages which is already present in the schema enums. While front-loaded with core purpose, it could be more concise. The structure is logical but not optimally efficient for an agent.

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 5 parameters, no output schema, and payment integration, the description covers most needs: payment flow, language format, auto-detection, and critical caveat. However, it omits the return format (translated text) and whether the operation is synchronous or asynchronous, leaving 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%, but the description adds significant value: it explains that language parameters accept both English names and ISO codes (schema only shows enums), details the payment dependency on create_payment, and elaborates on the sourceLanguage auto-detection and pitfall. 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.' The verb-resource pairing is specific, and the tool is distinguished from siblings like 'transcribe_translate' (audio) by the focus on text. The mention of auto-detection and payment flow further clarifies its purpose.

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

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

The description implies usage for text translation and provides context about auto-detection, language format, and payment prerequisites. However, it does not explicitly state when to use this tool versus alternatives (e.g., not for audio translation), but the singleton nature of text translation among siblings makes this 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 full burden. It discloses the model (Real-ESRGAN), automatic model upgrades, payment requirement (5 sats, Bitcoin Lightning, no signup), and the need for a prior create_payment call. However, error handling, rate limits, and output format are not covered.

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

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

The description is three sentences plus a payment note, front-loading the main purpose. However, it includes technical details (ICCV 2021, PSNR, production runs) that add noise but not essential for tool selection.

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 does not specify the output format (e.g., base64 string, URL) or constraints (max image size). Given no output schema, this omission leaves agents uncertain about the return value, making it incomplete.

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

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

Schema description coverage is 100%, so description adds value beyond schema. It clarifies the scale enum meaning, mentions face_enhance as optional, and explains the payment dependency. This extra context 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 clearly states 'Upscale images 2x or 4x with neural super-resolution', specifying a concrete verb, resource, and scale options. It distinguishes this from interpolation and mentions optional face enhancement, differentiating it from sibling tools like analyze_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?

The description implies usage context (recovering real detail from low-res images, not interpolation) but does not explicitly state when to use this tool vs alternatives or when not to use it. No sibling tool comparisons are 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?

Beyond the basic 'openWorldHint' annotation, the description discloses crucial behavioral traits: STT is automatically muted during injection to prevent echo, and no additional payment is needed. It also notes that mp3/opus encoding requires ffmpeg (not yet available in MVP), which is important operational context.

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

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

The description is three clear sentences, front-loading the main action. Every sentence adds distinct value: mode details, STT muting, and payment note. 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?

Given the tool has 6 parameters and no output schema, the description covers the main behavioral aspects well but omits return values (e.g., success/failure indication). The context signals indicate moderate complexity, and the description handles most needs except what the agent should expect back.

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 by explaining the two modes (text vs. audio_base64 + encoding), clarifying that 'language' is an override, and that 'voiceDescription' is a free-form TTS parameter. This exceeds 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 the tool injects audio into an open Voice Bridge call, with two explicit modes (text-to-speech and custom audio). It uses specific verbs ('inject', 'synthesize', 'bring your own audio') and distinguishes itself from sibling tools like 'open_voice_bridge' 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?

The description indirectly implies usage after opening a session (requires sessionId) and mentions STT muting behavior. However, it does not explicitly state when not to use this tool or contrast with alternatives like 'text_to_speech'. The exclusion of mp3/opus is noted but as a limitation.

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 return format ({success, slug, newVoteCount}), cost (1 sat per vote), and that multiple votes are allowed. No annotations provided, so description carries full burden. Missing potential rate limits or idempotency, but sufficient for this simple mutation.

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 covering purpose, return format, cost/multiplicity, and prerequisite. No unnecessary words, all information 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?

No output schema, but description includes return format. Prerequisites and cost are clear. Only two params with full schema descriptions. Adequate for an AI agent 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?

Schema coverage is 100% (both params have descriptions). Description reinforces that 'slug' comes from list_planned_services and 'paymentId' must be a valid paid 1-sat payment. Adds moderate 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?

Specifically states 'Vote for a planned service to be built next' with clear verb and resource. Distinguishes from siblings like list_planned_services (which discovers slugs) and create_payment (which handles 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?

Explicitly states prerequisite: 'Call list_planned_services first' and 'Requires create_payment with toolName="vote_on_service"'. Also explains cost per vote and prioritization logic, giving clear context for when to use.

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