RegiAI

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

Annotations already indicate non-read-only and open-world behavior, but the description adds significant context: asynchronous execution, the returned generation_id, the need to poll get_generation until 'completed', and the cost of $0.03 per image. This goes beyond annotations and assists the agent in correctly invoking and handling the tool.

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

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

Two sentences, zero filler. The purpose is front-loaded, then cost and async behavior are stated clearly. Every word earns its place.

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

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

For a single-parameter tool with an async pattern, the description covers the essential call flow (submit image → get generation_id → poll get_generation). It does not specify output format or error handling, but the tool is simple and the agent can infer or check get_generation's definition. Adequate 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% as the image parameter is fully documented. The description adds no extra details about the parameter format or constraints beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description states a specific transformation: 'Turn photos into anime.' This is a clear verb+resource combination that distinguishes this tool from the many image-related siblings like ai_photo_colorizer or ai_image_editor. No ambiguity about what it does.

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

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

The context is clear—use when anime conversion of a photo is desired. It does not explicitly exclude alternatives, but given the sibling set, this unique niche is apparent. No when-not guidance, but the purpose is specific enough to infer usage.

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

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

The description discloses valuable behavioral details beyond the annotations: async execution, a generation_id return, polling via get_generation, and pricing with a minimum charge. It does not cover auth, rate limits, or failure states, but the core async behavior is well communicated.

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

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

Two tight sentences: the first front-loads the core purpose and price, the second explains the async workflow. No filler or redundant restating of the schema, and every sentence carries actionable information.

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

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

For a two-parameter async tool with no output schema, the description adequately explains the return handle and polling pattern. It could add details about what happens when target_language is omitted and mention other possible statuses, but the essentials for correct invocation are present.

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

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

Schema description coverage is 100%, so the schema already documents 'video' and 'target_language'. The description adds cost and polling context, but no extra parameter-level semantics such as accepted formats, defaults, or language selection behavior beyond the enum.

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

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

The description opens with 'Dub speech into 18 languages,' which specifies a concrete verb, object, and scope. This cleanly separates the tool from siblings like ai_speech_to_text, ai_subtitle_generator, and ai_video_to_audio, since dubbing to a target language is a distinct operation.

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

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

The description provides a clear workflow: run asynchronously, receive a generation_id, and poll get_generation until status is 'completed'. However, it does not explicitly state when to prefer this tool over alternatives or when not to use it, leaving sibling differentiation to inference.

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

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

With annotations (readOnlyHint=false, openWorldHint=true), the description adds value beyond them: it discloses the async nature, the need to poll get_generation, and the cost per swap. These operational details are not conveyed by the annotations alone.

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 with no waste: the first establishes purpose, the second packs in cost and async behavior. It is front-loaded 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?

For a generate-then-poll tool without an output schema, the description covers the essential workflow (async, polling, cost) and consent is captured in the required schema. It does not describe return payload details or error handling, but those are minor given the polling pattern. Overall, 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 description coverage is 100%; each parameter already has clear descriptions. The tool description adds no additional parameter meaning beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description states a specific verb+resource: 'Put yourself in any body and outfit' which clearly differentiates it from sibling tools like ai_head_swap or ai_outfit_changer. It also mentions cost and async behavior, giving a distinctive identity.

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 workflow guidance: 'Runs asynchronously: returns a generation_id; call get_generation until status is "completed".' This tells the agent exactly how to invoke and poll, referencing the sibling get_generation. However, it does not explicitly compare with alternatives like ai_character_replace or ai_clothes_changer to help select among them.

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 that the operation is asynchronous and returns a generation_id, which is key behavioral information not available in annotations (annotations only have readOnlyHint=false and openWorldHint=true). It also mentions the starting price, which is a side effect (cost) and useful context. This adds value beyond the schema and annotations, though it doesn't detail error handling or side effects like potential data loss, but for a generation tool, the async pattern is the main behavioral trait.

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

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

The description is concise and front-loaded with the core purpose ('Replace characters in videos'), then provides critical operational details (cost, async behavior) in a single additional sentence. Every word earns its place, with no filler or redundancy.

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

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

Given the tool's complexity (asynchronous, 4 params, no output schema), the description provides the essential guidance needed: async flow and the follow-up step. It does not describe the return structure (e.g., what 'generation_id' looks like), but the schema covers input parameters thoroughly. The lack of an output schema is acceptable since the description directs users to call get_generation. It's nearly complete, but could mention error handling or rate limits, but those are not critical for a first call.

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

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

Since schema description coverage is 100%, the schema already documents all parameters (video, character_image, prompt, resolution) with descriptions. The tool description does not add additional meaning beyond the schema, such as formatting details or examples. However, it does add slight context by mentioning 'from $0.75' which could relate to cost for processing, but that's not parameter-specific. Baseline 3 is appropriate as the schema covers the 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 ('Replace characters in videos') and the resource (videos). It distinguishes from related siblings like ai_face_swap_video by focusing on character replacement, though it does not explicitly name the sibling. The purpose is clear and specific enough for an agent to understand the tool's core function.

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 essential usage context by noting the asynchronous behavior and the need to poll get_generation until completion, which is critical for correct invocation. However, it does not specify when to use this tool over others (e.g., ai_face_swap_video or ai_head_swap) or when not to use it. The 'when' is implied by the tool's function, but no explicit alternatives or exclusions are 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?

Annotations already indicate this is not read-only, and the description adds important behavior beyond that: a cost of $0.05 per try-on and the asynchronous execution flow with a generation_id. This gives an agent accurate expectations about side effects and follow-up steps 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?

Three short sentences deliver purpose, cost, and the critical async pattern, all front-loaded with zero filler. Every sentence earns its place.

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

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

For an async generation tool with no output schema, the description covers the essential flow: what it does, what it costs, what it returns, and how to retrieve the final result. It doesn't discuss failure modes or image constraints beyond the schema, but the core usage loop is complete.

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

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

Schema description coverage is 100%, with both person_image and garment_image clearly documented in the schema itself. The description adds no parameter-specific meaning, which is acceptable but not above the baseline.

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

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

The description states a specific verb and resource ('Try on outfits virtually') and is clearly not a tautology. However, it does not distinguish itself from close siblings like ai_dress_changer or ai_outfit_changer, so an agent may struggle to choose among them.

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

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

The description gives clear, actionable context: this is a paid virtual try-on tool and it is asynchronous, so the agent knows to poll get_generation. But it never mentions alternatives or conditions for choosing this tool over the many related clothing/outfit siblings, so the when-to-use guidance is only implied.

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=false, so the description correctly implies a mutating operation. It adds valuable behavioral context beyond annotations: cost ($0.10 per photo) and async behavior with polling instructions. This transparency helps the agent understand side effects and workflow.

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

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

Two sentences, no fluff, front-loaded purpose. The async note and cost are included efficiently, making every word earn its place.

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

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

The description covers the essential workflow: input selfies, cost, async generation, and how to retrieve the result via get_generation. It doesn't mention consent requirement, but that is in the schema. For a tool with no output schema, this is complete enough.

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 five parameters have descriptions in the schema (100% coverage), so the description doesn't need to detail them. It references 'two selfies' aligning with person_1 and person_2, but adds no new semantic meaning. 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 action ('Make couple photos') and the input ('from two selfies'), which distinguishes it from sibling tools like face_swap or image_generator. It is specific about the resource it operates on.

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 guidance on the asynchronous workflow: returns a generation_id and instructs to call get_generation until completed. It doesn't explicitly name alternatives but makes the use case clear and points to the follow-up tool, which is sufficient for this 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?

Annotations already indicate a mutation (readOnlyHint=false) and open-world generation (openWorldHint=true). The description adds valuable behavioral context: the cost per image ($0.10) and the asynchronous pattern (returns generation_id, poll get_generation). These are critical operational details not covered by annotations. It does not contradict annotations and provides useful non-obvious behavior.

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

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

The description is exceptionally concise: two sentences with zero fluff. It front-loads the core purpose, then immediately states the cost and the asynchronous workflow. Every sentence earns its place, and the structure makes it easy to scan.

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 (3 parameters, no output schema), the description explains the key operational flow (async polling) and the cost. It does not describe error handling, image constraints beyond the schema, or the expected output format, but these are either covered by the schema or not critical for a basic call. The async return mechanism is clearly explained, which is essential. A 4 is appropriate because it covers the main gaps but omits some edge-case 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 description coverage is 100%, with each parameter (image, style, color) fully documented in the schema. The description adds no additional parameter-level meaning, such as how style interacts with the generation or format constraints on the image URL. Since the schema already covers the parameters, the baseline of 3 applies.

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

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

The description clearly states the action ('Try on dresses') and the resource (the user's image). It is specific enough to distinguish from generic image editors, but it does not explicitly differentiate from sibling tools like ai_clothes_changer or ai_outfit_changer, which likely have overlapping purposes. The verb and resource are clear, but the lack of explicit sibling differentiation prevents a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that this is specifically for dresses, nor does it reference any sibling tools. An agent must infer from the name and schema alone, which is insufficient for selecting among the many similar AI alteration 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?

The description adds meaningful behavioral context beyond the annotations: it notes the $0.03 cost, and clearly describes the asynchronous flow by stating it returns a generation_id and that get_generation should be polled until status becomes 'completed'. This gives an agent a clear expectation of side effects and follow-up work. No contradiction with readOnlyHint=false exists.

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

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

Three short sentences cover purpose, cost, and async behavior with zero filler. The core action is front-loaded, and each remaining sentence adds necessary operational 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?

For a low-complexity tool with two fully described parameters, the description is nearly complete: it states the required inputs implicitly, explains the immediate return value, and tells the agent how to retrieve the final result. The absence of an output schema is largely compensated by the explicit get_generation polling instruction, though the final output format is left to get_generation.

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 defines both parameters. The description does not add extra parameter meaning beyond what the input schema provides, so the baseline of 3 is appropriate.

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

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

The description clearly states a specific action and resource: 'Change facial expressions.' It is unambiguous about what the tool does, but it does not explicitly differentiate itself from siblings like ai_image_editor or face_swap, so it falls short of full sibling differentiation.

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

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

The purpose implies when to use it: when the agent needs to modify a facial expression. However, there is no explicit guidance about alternatives or exclusions, such as when to prefer ai_image_editor or face_swap instead. The async workflow guidance is useful but is more about usage mechanics than use-case 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?

The description provides substantial behavioral detail beyond annotations: it is asynchronous, returns a generation_id, requires polling get_generation until completed, and specifies cost and duration limits. Annotations only indicate readOnlyHint=false and openWorldHint=true, so this added context is highly valuable for correct invocation.

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 concise sentences: purpose, cost/duration, and async flow. Each sentence carries necessary information with no filler, and the most critical operational detail (poll get_generation) is clearly stated.

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 paid async operation, the description covers the essential flow: how to launch, how to retrieve the result, and the cost. It does not mention failure modes or explicit alternatives, but given the schema's completeness and the polling instruction, it is mostly sufficient for an agent to invoke 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 each parameter (face, video, consent) already has clear descriptions in the schema. The tool description adds no additional parameter-specific meaning, so the baseline score of 3 applies.

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

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

The description states the specific action 'Swap faces in videos', which clearly identifies both the verb and resource. It is distinguishable from siblings like face_swap or ai_head_swap because it explicitly targets videos, though it does not name those alternatives.

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

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

The description gives no explicit guidance about when to choose this tool over similar ones (e.g., face_swap, ai_head_swap, gif_face_swap). It implies the use case through the purpose but lacks any 'use this when' or 'avoid when' instructions, leaving the AI to infer based on the name alone.

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 important behavior beyond the annotations: it runs asynchronously, returns a generation_id, and requires polling via get_generation. It also mentions the $0.10 per-swap cost. Although readOnlyHint=false already indicates mutation, the async contract is valuable supplemental context.

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

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

The description is two concise sentences with zero filler. The core purpose is front-loaded, followed by the pricing and the critical async polling instruction. Every sentence earns its place.

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

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

Given there is no output schema, the description compensates by telling the caller to use get_generation to retrieve the result. It covers the essential workflow for a two-parameter async tool. Minor details such as error states or retry behavior are not mentioned but are not necessary for basic invocation.

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

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

The input schema already documents both parameters with meaningful descriptions (body photo keeps pose/outfit; head photo provides face/hair), giving 100% schema coverage. The tool description adds no extra parameter-level semantics, so the baseline score of 3 applies.

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

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

The description states a clear action and resource: 'Swap heads in photos.' The verb 'swap' and noun 'heads in photos' make the core function unmistakable. It does not explicitly distinguish itself from sibling tools like face_swap or ai_body_swap, though the head-specific wording partially does so.

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

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

The description gives clear operational guidance: the tool runs asynchronously and the caller must poll get_generation until status is 'completed'. However, it provides no explicit guidance on when to choose this tool over close alternatives such as face_swap, ai_body_swap, or multiple_face_swap.

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 cost ($0.03 per image), asynchronous execution, and the return/polling contract (generation_id, status 'completed'). This goes well beyond the annotations, which only indicate that the tool is not read-only and operates in an open world.

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

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

Three short sentences each carry distinct information: purpose, pricing, and async behavior. There is no redundancy and the most critical information is front-loaded.

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

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

For a simple two-parameter tool with no output schema, the description provides the essential return identifier and polling instructions. An agent has everything needed to invoke the tool and retrieve the result.

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

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

Schema description coverage is 100%, so the schema already documents both parameters and their formats. The description adds no extra parameter-specific meaning beyond reiterating that the tool takes an image and a prompt.

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 names a specific verb ('edit'), resource ('photos'), and method ('with a prompt'), making the tool's purpose unambiguous. It also distinguishes this from image generation tools like ai_image_generator, and the async note clarifies that the output is a generation_id, not an immediate edited 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 when to use this tool: when a photo should be edited via a prompt. It gives a concrete follow-up workflow (call get_generation until completed) but does not explicitly contrast with sibling tools or state when an alternative should be preferred.

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 signal that this is not read-only and is open-world, but the description goes further by disclosing a concrete side effect (billing $0.03 per image) and the asynchronous execution pattern. This adds real behavioral context beyond the annotations. It does not contradict the annotations, and there is no mention of other side effects, but the disclosed information is meaningful.

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 exceptionally concise: two sentences, zero filler. The primary purpose is front-loaded, and the critical asynchronous workflow and cost are conveyed in the second sentence. Every word earns its place, and the structure is optimally scannable.

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 moderate complexity (3 parameters, no output schema) and the rich sibling set, the description covers the essential operational details: purpose, cost, and the polling protocol with a specific sibling (get_generation). It omits details like possible failure modes or what the expanded image looks like, but these are not critical for a correct first call. The description is complete enough for an agent to use the tool correctly.

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

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

All three parameters are fully described in the input schema with 100% coverage, including the enum for aspect_ratio and the max length for prompt. The description does not add any parameter-specific details, which is acceptable given the schema already carries the explanatory burden. The baseline of 3 applies.

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

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

The phrase 'Extend images with AI' clearly states a specific verb (extend) and resource (images), which distinguishes it from general-purpose tools like ai_image_editor or ai_image_generator. However, it does not explicitly name an alternative tool, so it misses the full 5 that comes with explicit sibling differentiation.

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 operational guidance: it explains that the call is asynchronous and instructs the agent to poll get_generation until status is 'completed'. This is valuable for invoking the tool correctly. However, it lacks any guidance on when to choose this tool over alternatives, leaving the selection decision to inference.

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

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

Annotations indicate readOnlyHint=false and openWorldHint=true, so the mutating nature is already known. The description adds valuable behavioral context by disclosing asynchronous execution, the returned generation_id, and the required polling step, which are not visible in annotations or schema.

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

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

The description is tight and efficient: three short sentences cover what it does, pricing, and the key asynchronous polling workflow. Every sentence contributes necessary information, and the main action is front-loaded.

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

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

The description is largely complete for invocation: it explains the asynchronous flow, what is returned (generation_id), and how to get the final result via get_generation. It does not describe potential error states or other status values, but for a simple text-to-image call with a needed follow-up, it is sufficient.

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

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

Schema description coverage is 100%, and the schema already documents prompt, model, and aspect_ratio with enums and constraints. The description adds only high-level context like '12 models' and pricing, not meaningful per-parameter semantics 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 'Text to image with 12 models', giving a specific function and resource scope. It is understandable on its own, though it does not explicitly differentiate this tool from the sibling 'generate_image' or other image-generation 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?

It provides clear usage context by explaining the asynchronous workflow: returns a generation_id and directs the caller to poll get_generation until status is 'completed'. However, it does not give explicit when-to-use versus alternative image tools or state 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?

The description adds substantial behavioral context beyond the sparse annotations: it reveals the pricing model ($0.35/video) and the asynchronous execution flow (returns a generation_id, poll get_generation). This is exactly the kind of operational behavior an agent needs to know and would not infer from the schema.

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

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

Two sentences cover purpose, cost, and async workflow with zero filler. The purpose is front-loaded and each clause earns its place, making it easy to scan.

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 schemacompanion, the description covers the essential operational loop: it returns a generation_id and tells the caller how to wait for completion. It does not cover failure handling, format constraints, or what the final result will look like, but the schema covers inputs, and the referenced get_generation follows up.

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

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

The schema already provides 100% parameter coverage with descriptions for audio, video, and consent. The description mentions audio generically but does not add any new detail about parameter format, constraints, or relationships beyond what the schema states, so the baseline of 3 is appropriate.

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

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

"Sync lips to any audio" is a clear verb+resource combination that evokes the tool's function immediately. It does not explicitly distinguish from siblings like ai_talking_photo, but the phrase is specific enough that an agent can generally tell it apart.

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?

There is no guidance on when to choose this tool over alternatives or when not to use it. The only mention of another tool is get_generation for polling completion, which is a follow-up step rather than an alternative 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?

Beyond annotations, it discloses the asynchronous execution model, the returned generation_id, the polling requirement, and the per-song cost. This is exactly the behavioral context an agent needs and goes well beyond the readOnly/openWorld flags.

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

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

Three short sentences, each carrying distinct value: purpose, cost, and async workflow. It is front-loaded and contains no filler.

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

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

For a tool with no output schema, the description adequately explains the invocation flow and how to obtain the result. It could be slightly more complete by noting what get_generation returns on failure or expected wait times, but the core flow is fully covered.

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

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

Schema coverage is 100%, with descriptions for prompt, lyrics, and is_instrumental. The tool description adds no parameter-level detail beyond restating that a prompt produces songs, so it relies on the schema.

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

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

Description opens with 'Songs from a prompt,' immediately stating the resource (songs) and the input (prompt). The async detail with generation_id further distinguishes it from sibling generation tools by signaling it is not synchronous and pairs with get_generation.

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

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

It provides clear usage context: input is a prompt and the result must be polled via get_generation. However, it does not explicitly say when to prefer this tool over siblings like ai_sound_effects or ai_voice_generator, nor does it state 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?

The description adds meaningful behavioral context beyond the annotations: the $0.10 per image cost is disclosed, and the asynchronous contract (returns generation_id, poll get_generation until 'completed') is explicitly stated. This is valuable operational detail that annotations (readOnlyHint=false, openWorldHint=true) do not provide.

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

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

Three short sentences, each earning its place: the core function, the cost, and the async retrieval pattern. Information is front-loaded and there is zero 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 simple 2-parameter tool with no output schema, the description covers invocation, cost, return shape (generation_id), and the subsequent polling step. The only notable gap is the lack of differentiation from similar outfit/clothing tools, but the operational flow for calling this tool correctly is complete.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters (image as URL/base64, outfit with 500-char limit). The description adds no parameter-specific information, matching the baseline of 3 for well-covered schemas.

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

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

The description states a specific verb and resource — 'Change outfits with a prompt' — making the core function clear. However, it does not differentiate the tool from near-identical siblings like ai_clothes_changer and ai_dress_changer, which appear to serve the same purpose, so it falls short of a 5.

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

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

No guidance is given on when to choose this tool over ai_clothes_changer or ai_dress_changer, and with over 50 siblings this is a real selection hazard. The async workflow note hints at how to use it but provides no when/when-not context or 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 adds important behaviors beyond annotations: async execution, polling requirement, and a $0.03 charge. Annotations only say readOnlyHint=false and openWorldHint=true, so the description carries the load and does so clearly. It does not cover failure modes or data retention, but it covers the core workflow.

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

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

Two tight sentences: the first states purpose and price; the second explains the async workflow. This is appropriately front-loaded and has 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 one-parameter async tool, the description covers the essential steps: submit image, receive generation_id, poll get_generation. Cost and input format are included, and no output schema exists to explain. It could mention error handling, but it is otherwise complete.

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

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

The schema already fully documents the single 'image' parameter with 100% coverage, including accepted formats (URL or data URI). The description adds no new parameter-level semantics, so the baseline of 3 applies.

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

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

The description clearly states the tool's function: 'Colorize black & white photos' with a specific verb and resource. It implicitly distinguishes from the sibling ai_video_colorizer by limiting scope to photos, and the title reinforces this. No ambiguity about what task it performs.

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

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

The description gives concrete invocation guidance: it is asynchronous, returns a generation_id, and instructs the user to call get_generation until status is 'completed'. It also mentions cost per photo, which helps decide whether to use it. It does not explicitly name alternatives or exclusion criteria, but the photo-specific scope provides enough 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?

The description adds meaningful behavioral context beyond the annotations: the operation is asynchronous, returns a generation_id, requires polling, and costs $0.10 per image. It does not detail failure modes or exact result format, but the core non-obvious behavior is disclosed.

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

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

The description is two sentences with no filler. It front-loads the core purpose, then the cost and the critical asynchronous workflow, making every sentence earn its place.

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

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

The description covers the essential call sequence, required/optional inputs are fully in the schema, and the asynchronous continuation is explained. It is slightly light on final output details, but there is no output schema and the polling instruction sufficiently orients the agent.

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

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

Schema description coverage is 100%, so the input schema already documents style, persona, and input_image. The description adds no extra parameter-level meaning, which is acceptable given the complete schema; the baseline of 3 applies.

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

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

The description identifies the tool's resource and output: stylized selfies and avatars, and implies the generation verb from the title. It is distinct enough from unrelated siblings, though it does not explicitly differentiate from close alternatives like ai_anime_filter or face_swap.

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

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

The description gives clear procedural context: run asynchronously, receive a generation_id, and poll get_generation until status is completed. It does not explicitly state when to prefer this tool over alternatives, but the stylized selfie/avatar scope provides a clear usage context without 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?

The description discloses key behavioral traits beyond annotations: it runs asynchronously, returns a generation_id, requires polling get_generation, and costs $0.05 per sound. The annotations only say readOnlyHint=false and openWorldHint=true, so the description carries the burden and does well. It doesn't mention failure modes or rate limits, but the async pattern and pricing are significant transparency wins.

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, zero waste. The core function is first, then pricing, then the critical async workflow. Every sentence earns its place and the most important operational detail (poll get_generation) is included without bloat.

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 2-parameter tool with 100% schema coverage and no output schema, the description is nearly complete. It explains the async flow and how to retrieve results, which is the main missing piece an agent would need. It doesn't describe the output format of get_generation, but that's a separate tool's responsibility. The pricing is a nice operational detail. Minor gap: no mention of what happens on failure or how long generation takes.

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

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

Schema coverage is 100%, so the schema already documents both parameters (prompt and duration). The description adds the pricing and async context but doesn't add parameter-level meaning beyond the schema. The duration enum is self-explanatory, and the prompt max length is in the schema. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states the tool's function: generating sound effects from text. It distinguishes itself from siblings like ai_music_generator and ai_voice_generator by specifying 'sound effects' and includes pricing and async behavior. The verb 'generates' plus the resource 'sound effects from text' 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 implies when to use this tool (when you need sound effects from text) and provides a clear usage pattern: call it, get a generation_id, then poll get_generation. It doesn't explicitly state when NOT to use it or name alternatives like ai_music_generator, but the async workflow guidance is strong and the sibling list provides context. The instruction to call get_generation is explicit and actionable.

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 are sparse (readOnlyHint:false, openWorldHint:true) so the description carries most of the burden. It discloses two important behaviors: per-file cost and asynchronous execution with polling. It doesn't mention failure modes or result format, but the async pattern is the most critical trait and is clearly stated.

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 with no filler: the purpose is the first sentence, then cost and async flow. Every sentence adds unique information and the most critical detail (async) is front-loaded after the purpose.

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

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

The tool has only 3 parameters and no output schema, yet the description covers the main operational need: how to handle the asynchronous response. It doesn't describe the final transcript content (whether it's in the generation result), but that is likely handled by get_generation, and the polling instruction is sufficient for an agent to proceed.

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% – each parameter (audio, language, translate) already has a description and language has an enum. The description adds no extra detail about parameter formats, defaults, or edge cases, so it doesn't elevate beyond the schema 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 opens with 'Transcribe audio to text', a specific verb+resource that clearly states the tool's function. It distinguishes itself from the many image/video siblings and from ai_audio_translator by using the word 'transcribe' rather than 'translate', so an agent can select it correctly even without opening the schema.

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

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

The description explains the asynchronous workflow (returns generation_id, poll get_generation) and the cost, which is useful for when to invoke it. However, it never names alternatives or states when not to use it, such as 'use ai_audio_translator for translation' – so the agent must infer the scope from the purpose alone.

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

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

Annotations provide readOnlyHint=false and openWorldHint=true, so the description's mention of asynchronous behavior and the need to poll adds valuable context beyond annotations. However, it doesn't disclose cost or rate limits, but it does mention the $0.10 per video cost, which is helpful. The async behavior is a key behavioral trait not captured in 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?

Three concise sentences with zero filler. The first sentence states the core action, the second provides pricing, and the third explains the async workflow. Effective front-loading of critical usage information.

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

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

Given the output schema is absent, the description explicitly mentions the return of a generation_id and the need to poll get_generation, which is essential for a complete async workflow. It covers the cost and basic workflow. It doesn't describe the output format of the final SRT, but that may be acceptable since it references a sibling tool for retrieval.

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% as all three parameters have descriptions. The description does not add extra meaning beyond the schema; it mentions the language and translate parameters indirectly. Since schema covers everything, baseline 3 applies.

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

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

States a specific verb and resource: 'Generate SRT subtitles' and clearly distinguishes from siblings like ai_speech_to_text and ai_audio_translator by focusing on subtitle generation. Could be more explicit about being a video-to-subtitle tool, but the purpose is 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?

Implies usage by describing the async flow (returns a generation_id, poll get_generation), which tells the agent how to use it. However, it doesn't explicitly state when to choose this over alternatives like ai_speech_to_text or ai_audio_translator. The async workflow is a clear usage guideline, but exclusions are missing.

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

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

Beyond the minimal annotations, the description discloses important runtime behavior: it runs asynchronously, returns a generation_id, requires polling, and costs $0.40 per 100 characters. This adds meaningful operational context 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?

Three short sentences convey purpose, cost, async behavior, and next-step polling with zero filler. The most important operational detail (polling via get_generation) is present 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 an asynchronous tool with no output schema, the description covers the essential flow: invocation, returned generation_id, and how to obtain the result. It omits polling interval and error cases, but these are moderate gaps given the clarity of the core contract.

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

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

The schema already documents all parameters with 100% coverage, so the baseline applies. The description adds no parameter-level semantics beyond cost scaling by character count, which is modest supplemental context.

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

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

The description clearly states the tool's function: making photos talk. It conveys a specific verb/resource pairing and includes the async contract, but it does not explicitly differentiate itself from similar siblings like ai_lip_sync or ai_voice_cloner.

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

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

The description gives a clear operational instruction — call get_generation until status is 'completed' — which is valuable guidance. However, it does not state when to choose this tool over alternatives, nor does it mention exclusions or 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?

Annotations only mark readOnly=false and openWorld=true, so the description must carry behavioral weight. It does: it discloses asynchronous execution, the generation_id return, the need to poll get_generation until 'completed', and pricing/duration limits. It omits failure/terminal status variety, but goes well beyond 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?

Three short sentences: purpose, price/length constraint, and polling contract. Front-loaded with the core action, no filler, and every sentence adds needed operational information.

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

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

For a one-parameter tool with no output schema, the description supplies the essential async workflow and the mechanism to retrieve results. Minor gaps remain around failure statuses and file-size/format restrictions, but the schema covers the video input format and the description covers the polling path.

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 fully defines the only parameter (video: public https URL or base64 data URI) with 100% coverage, so the baseline is 3. The description adds no extra parameter-level detail 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 opens with a specific verb and resource ('Colorize old videos') and adds practical constraints ($0.10 per video, up to 30s), so an agent knows what the tool does. However, it does not explicitly contrast with ai_photo_colorizer or other colorization/restyle siblings, so differentiation relies on the word 'video'.

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

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

It clearly states the tool is for colorizing videos and gives the invocation pattern (returns generation_id, poll get_generation), so the intended use is implied. It does not name alternatives or say when not to use it, leaving routing to inference.

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

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

The description discloses several behavioral traits beyond the annotations: the $1.50 cost, the +6s duration, asynchronous execution, and the required polling workflow with get_generation. This is substantial, actionable information that the annotations do not provide.

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

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

Three short sentences deliver purpose, cost, duration, and async workflow with zero filler. The most important usage fact (returns generation_id, poll get_generation) is front-loaded after the purpose.

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

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

For a simple two-param async tool with full schema coverage and no output schema, the description explains the return value and completion condition sufficiently. It could be slightly more complete by noting possible non-completed terminal statuses like 'failed', but nothing essential to invoking the tool is missing.

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

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

Schema description coverage is 100%, so both video and prompt are already documented in the input schema. The description adds cost and duration context, but no additional parameter-level meaning beyond what the schema provides, matching 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 states a specific action and resource: "Make clips longer," plus the concrete output of each extension (+6s). This clearly differentiates it from siblings like ai_video_upscaler (resolution) and ai_image_expander (images), even without naming them.

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

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

The description gives clear post-invocation guidance: "returns a generation_id; call get_generation until status is 'completed'." However, it does not state when to choose this tool over alternatives or any exclusions, so the when-to-use context is only implied by the purpose.

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 only indicate readOnlyHint=false and openWorldHint=true; the description adds the crucial asynchronous behavior, return of a generation_id, the polling pattern, and cost ('from $0.50'). These are valuable behavioral disclosures beyond the annotations, though it does not cover auth or rate limits, which are less critical here.

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 with zero filler: the purpose is front-loaded, and the async flow and cost are stated efficiently. Every sentence earns its place, making it easy for an agent to parse quickly.

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 generation tool with 4 parameters and no output schema, the description fully explains the necessary calling pattern: initiate with text/image, receive a generation_id, and poll get_generation. It covers the core operational requirement (async polling) and cost, so an agent has everything needed to correctly invoke and follow up on this tool.

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

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

Schema description coverage is 100%, so every parameter is documented in the schema. The description does not add extra semantic detail about parameters beyond what the schema provides, so the baseline of 3 is appropriate. It does not introduce any parameter-specific context that the schema lacks.

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

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

The description clearly states 'Text and image to video', naming the specific resource and action. It distinguishes from sibling tools like text_to_video and image_to_video by indicating it handles both modalities in one tool, so an agent can tell them apart without inspecting schemas.

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

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

The description gives clear usage context: it runs asynchronously and instructs to poll get_generation until status is 'completed'. However, it does not explicitly mention alternatives (e.g., use text_to_video for text-only) or state when not to use it, so it lacks explicit exclusions but provides solid operational 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?

The description clearly discloses the asynchronous behavior and the need to poll get_generation, which is not evident from annotations. It also mentions cost ('from $0.60'), adding transparency beyond the openWorldHint and readOnlyHint false annotations. No contradiction with annotations.

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

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

Two concise sentences with no wasted words. The core action is front-loaded, followed by cost and the essential async polling instruction. Every part earns its place.

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

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

For a tool with 3 parameters, full schema coverage, and an async pattern, the description covers the key operational steps: it states the purpose, the async nature, how to retrieve the result, and cost. It doesn't cover error handling or edge cases, but these are not essential for basic invocation.

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

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

Schema description coverage is 100%, so the schema already fully documents video, prompt, and quality. The description adds no additional parameter details beyond what's in the schema, so it meets the baseline of 3 but does not exceed it.

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

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

States the specific action 'Restyle videos with a prompt', which is clear and distinct from other video tools like colorize, upscale, or extend. The verb 'restyle' is specific enough to separate it from siblings, though it doesn't explicitly name alternatives.

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

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

Provides usage context for the asynchronous flow (returns generation_id, poll get_generation) but gives no guidance on when to choose this tool versus other video-restyle or editing tools. The polling instruction is useful, but there's no explicit when/when-not 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?

The description goes beyond the annotations by disclosing that execution is asynchronous, that a generation_id is returned, and that polling get_generation is required. It also adds cost information ($0.05 per video), which is useful operational context not present in the schema or annotations. There is no contradiction with 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 remarkably compact: two sentences with zero filler. It front-loads the core purpose, then immediately supplies cost and async behavior. Every sentence earns its place and adds actionable 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 that there is no output schema, the description correctly explains the return value (generation_id) and the required follow-up action. It covers the essential workflow an agent needs to invoke and monitor the tool. It does not address edge cases like invalid videos, but for typical usage this is sufficient.

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

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

Schema description coverage is 100%, so the schema fully documents both 'video' and 'prompt.' The description does not add extra parameter-level semantics, but it doesn't need to; the baseline of 3 is appropriate when the schema carries the load.

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

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

The description opens with a specific verb and resource: 'Add sound to silent videos.' This clearly distinguishes the tool from audio-generation siblings like ai_sound_effects or ai_music_generator by emphasizing that the input is a silent video. The purpose is immediately understandable and not a tautology of the name.

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

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

The description provides a clear usage context: it applies to silent videos, and it explains the asynchronous workflow of calling get_generation until 'completed.' It does not explicitly name alternative tools or state when not to use it, but the context is clear enough for an agent to identify the appropriate scenario.

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

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

Annotations provide readOnlyHint=false and openWorldHint=true, but the description adds critical behavioral context: the tool is asynchronous (returns a generation_id rather than the upscaled video), it has a 10-second duration limit, and it costs $0.80 per video. This is exactly the kind of behavioral disclosure that helps an agent avoid hanging or misinterpreting the response. It doesn't mention failure modes or rate limits, but the key async behavior is well covered.

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

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

Three sentences, each earning its place: the first states the core action and output resolution, the second gives pricing and limits, the third explains the async workflow. The most important operational detail (async behavior) is front-loaded in the final sentence, and there is zero 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 single-parameter tool with a 100% documented schema, the description covers the essential operational context: what it does, what it costs, what the limits are, and how to retrieve the result. The only gap is that it doesn't describe the output format of get_generation or what the final result looks like, but since there's no output schema and the async pattern is clearly explained, this is a minor omission.

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 fully documents the single 'video' parameter. The description adds context about the video constraints (up to 10s, 1080p) which is useful, but doesn't add new parameter-level semantics beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Upscale'), a specific resource ('videos'), and a concrete target resolution ('to 1080p'). It also includes pricing and duration limits, which further disambiguate it from siblings like ai_video_colorizer, ai_video_restyle, and upscale_image. The tool's identity is 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 clearly explains the asynchronous workflow: it returns a generation_id and instructs the agent to call get_generation until status is 'completed'. This is explicit usage guidance for the primary flow. However, it doesn't explicitly state when NOT to use this tool versus alternatives like upscale_image or ai_video_restyle, though the name and purpose make the distinction fairly obvious.

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

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

Annotations provide readOnlyHint=false (implying it may mutate or have side effects) and openWorldHint=true. The description adds critical behavioral context: it costs money, runs asynchronously, and requires polling with get_generation. This goes beyond what annotations alone reveal, helping the agent understand the operational behavior.

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

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

The description is brief and front-loaded with the core purpose. Every sentence adds value: it states the function, clarifies cost, and outlines the async requirement. It could be slightly more structured but is efficient and easy to scan.

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 two well-documented parameters and no output schema, the description provides essential operational detail: the async nature and the need to poll get_generation. It does not specify return format of get_generation, but that is covered by the sibling tool's schema. Overall, enough for an agent to proceed confidently.

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

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

The input schema already documents both parameters thoroughly, including enum values for 'keep' and format for 'audio'. The schema description coverage is 100%, so the description adds no additional parameter-specific meaning. The schema does the heavy lifting, so a baseline of 3 is appropriate.

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

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

The description clearly states the primary function: 'Separate vocals and music.' It uses a specific verb and resource, making it immediately distinguishable from sibling tools like ai_audio_translator or ai_speech_to_text. The mention of cost and async behavior adds specificity beyond a generic purpose.

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

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

The description provides clear context on how to use the tool: it explains the async flow, telling the agent to call get_generation until status is 'completed'. However, it does not explicitly state when not to use this tool or mention alternatives, so it lacks explicit exclusions but still gives strong 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?

The description adds valuable behavioral context beyond the annotations: cost ($0.05 per recording), asynchronous execution, a generation_id return value, and the requirement to poll get_generation until status is 'completed.' This meaningfully discloses how the tool behaves.

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

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

Three short sentences each carry unique information: purpose, cost, and async workflow. The description is front-loaded with the main purpose and contains no filler or redundant restatement of the schema.

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

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

With no output schema, the description appropriately explains the return value (generation_id) and how to obtain the final result via polling. It omits error handling and supported audio formats, but the provided information is sufficient for basic correct invocation.

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

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

Schema description coverage is 100%, with the input schema already explaining consent, source_audio, and reference_audio. The description adds no parameter-specific meaning beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Change a voice in any recording.' This clearly identifies the core operation and distinguishes it from voice generation or cloning siblings by focusing on modifying an existing recording, though it does not explicitly name alternatives.

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

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

There is no guidance on when to use this tool versus sibling tools like ai_voice_cloner, ai_voice_generator, or ai_audio_translator. The async polling instructions are useful how-to information, but they do not help an agent choose between 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?

Beyond the annotations (readOnlyHint=false, openWorldHint=true), the description adds valuable behavioral context: the tool is asynchronous and returns a generation_id, and it has a measurable cost of $0.10 per 1,000 characters. This goes well beyond what the annotations convey, though it doesn't discuss failure modes, inputs that get rejected, or security/consent enforcement.

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

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

Three short sentences with zero filler: purpose first, then cost, then the async flow. Every sentence earns its place and the most critical operational fact (poll get_generation) is stated explicitly.

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 5-parameter, asynchronous tool with no output schema, the description covers the critical success path (poll get_generation) and cost model. Minor gaps remain — no mention of what the completed generation returns, no clarification of consent implications, and no failure/error behavior — but an agent has enough to invoke and verify the call 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 five parameters, including the consent requirement and the audio format for reference_audio. The baseline of 3 applies; the description's character-based pricing and async note add operational context but no per-parameter semantic detail 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?

"Clone a voice from a sample" is a specific verb+resource with a clear scope. The 'from a sample' qualifier implicitly distinguishes it from siblings like ai_voice_generator and ai_voice_changer, but the description never names those alternatives explicitly, so differentiation is left to inference.

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

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

The description gives no guidance on when to choose this tool over ai_voice_generator, ai_voice_changer, or ai_audio_translator. The async polling note ('call get_generation until status is completed') is a flow instruction, not usage-selection guidance; no prerequisites, exclusions, or alternative conditions are stated.

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

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

The description reveals important behavior beyond the sparse annotations: per-character pricing with a minimum charge, asynchronous execution, and the return of a generation_id that must be polled. It does not cover failure states or timeout behavior, but the main behavioral surprises are disclosed.

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

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

Three compact sentences carry substantial value: purpose, cost, and lifecycle contract. It is front-loaded with the core operation and contains no filler or repetition.

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

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

For a simple three-parameter tool with a complete schema, the description covers everything needed to invoke it correctly: input text, optional enums, cost, asynchronous behavior, and the explicit polling handoff to get_generation. No output schema exists, but the description tells the agent where to fetch the result.

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

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

Schema coverage is already 100%, and the description adds no per-parameter semantics beyond the schema. The pricing note gives useful context about text cost, but emotion and voice_id behavior remain entirely defined by the schema and enum values.

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

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

The description opens with a precise operation: text becomes natural speech, which is instantly distinguishable from the many sibling tools such as ai_speech_to_text, ai_voice_changer, ai_audio_translator, and ai_music_generator. It combines a specific verb, resource, and transformation.

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

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

The description gives clear usage context: it is billed, runs asynchronously, and requires polling via get_generation until status is 'completed'. It does not explicitly name alternatives or state when not to use the tool, so it falls just short of full alternative guidance.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the description is not burdened with establishing safety. It adds useful context by mentioning the optional system prompt and per-call cost, but it does not disclose output format, failure behavior, or supported image constraints beyond the schema.

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

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

The description is two short sentences: one states the tool's function and optional prompt, the other states the cost. It is front-loaded and contains no filler or redundant restatement.

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

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

For a tool with only three parameters, annotations, and a clear schema, the core invocation is adequately covered. However, the absence of an output schema means the description should ideally indicate what the response looks like (e.g., text answer), and it does not help an agent choose between this and similar sibling tools.

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

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

Schema description coverage is 100%, with image, prompt, and system_prompt each already explained. The description adds marginal value by noting the optional system prompt and reinforcing open-ended questions, but the schema carries most of the parameter meaning.

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

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

The description clearly states a specific action ('Ask any question about an image') and identifies the optional system prompt. It is unambiguous but does not distinguish itself from similar siblings like answer_picture_question, describe_image, or image_to_text.

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

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

The description says 'any question' but provides no guidance on when to use this tool versus the many similar image-analysis siblings. There are no exclusions, alternatives, or selection criteria, so an agent must infer the appropriate 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?

Annotations declare readOnlyHint=true and openWorldHint=true, covering safety. The description adds the cost per image ($0.01) and the specific problem domains, which are useful behavioral details not provided by annotations. 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?

Extremely concise and front-loaded: the core purpose is stated first, followed by cost. Every sentence earns its place with no filler.

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

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

For a simple one-parameter tool with annotations covering safety, the description is adequate but lacks explicit mention of the return format or any caveats about image quality or problem types. Given no output schema, a brief note on expected response 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%, with the 'image' parameter clearly described as a public URL or base64 data URI. The description adds no additional parameter details, so it matches the baseline for 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 solves math, physics, or chemistry problems from an image. This is a specific verb ('solve') with a defined resource and domain, distinguishing it from image editing or description tools among siblings.

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

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

No guidance on when to use this tool versus alternatives like describe_image or analyze_image. The description gives no explicit conditions or exclusions, leaving the agent to infer appropriate usage from the problem domain.

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 adds important behavioral details beyond the annotations: it is paid ($0.10 per image), runs asynchronously, returns a generation_id, and instructs the caller to poll until status is 'completed'. This meaningfully clarifies what an agent should expect when invoking the tool.

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

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

Three short sentences, each carrying distinct information: the visual effect, the cost, and the asynchronous workflow. There is no filler or repetition of schema contents.

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 an asynchronous image-generation tool with no output schema, the description adequately explains how to retrieve the result by polling get_generation. It could mention failure modes or estimated runtime, but the essential call-and-retrieve flow is complete.

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

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

Schema description coverage is 100%, so parameter meanings are already documented in the schema. The description adds no detail about the color or style parameters beyond what the schema provides, which matches the baseline expectation.

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?

‘See yourself with braces’ clearly communicates the tool's effect: it transforms a photo to add braces. It implies the input is an image and is distinct from the sibling tools, though it stops short of an explicit verb+resource phrasing like 'applies braces to an 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 gives clear usage context: the tool is asynchronous and must be polled via get_generation. However, it provides no guidance on when to choose this tool over sibling image filters/editors, so selection criteria are only implied by the name and effect.

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=true and openWorldHint=true, so the safety profile is covered. The description adds useful pricing information ($0.01 per image) but does not disclose output formatting, limits, or how the description is produced beyond the basic behavior already implied by the description.

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

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

The description is two short sentences with no filler. The core purpose is front-loaded, and the cost note is the only extra information, which earns its place for practical decision-making.

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

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

For a single-parameter read-only tool with complete schema coverage, the description is mostly sufficient: it states the output type ('text description') and cost. It lacks any note about response structure or edge cases, but given the simplicity and annotations, the gap is minor.

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

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

The schema covers 100% of the parameter meaning, explicitly specifying that the image must be a public HTTPS URL or base64 data URI. The description adds no additional parameter-level details, so the 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 a specific verb ('Get') and resource ('a detailed text description of an image'). However, it does not distinguish itself from similar siblings like analyze_image, image_to_text, or answer_picture_question, so an agent cannot tell exactly why this tool is the right one among those.

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

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

No guidance is given about when to use this tool versus its alternatives. The description only states the function and pricing, leaving the agent to infer the intended use case without any comparison to analyze_image or image_to_text.

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 mark the tool as non-read-only, and the description adds useful cost context ($0.10 per swap). However, it does not disclose output format, behavior when no face is found, multiple-face handling, or whether processing is asynchronous. No contradiction with annotations.

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

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

A single, well-structured sentence with the operation front-loaded and the cost appended. There is no filler and no unnecessary repetition of schema content.

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

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

For a simple two-parameter image operation, the essential invocation facts are present: source image, target image, and cost. The main gap is the lack of any statement about the return value or response shape, but the operation is straightforward enough that this is a minor omission.

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% for format, but both parameter descriptions are identical, so the schema alone does not indicate which image is the source and which is the target. The description supplies that essential distinction: image is the face source and target_image is the destination person.

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 names a concrete operation ('Put the face from image onto the person in target_image') with clear source and target roles. It is not a tautology, but it does not explicitly distinguish itself from related sibling tools like ai_face_swap_video, gif_face_swap, or multiple_face_swap.

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

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

No explicit when-to-use or when-not-to-use guidance is provided, and no sibling alternatives are mentioned. An agent can infer the basic use case from the verb, but it gets no help deciding between this and the many related face/head/body swap 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 (readOnlyHint=false, openWorldHint=true) already signal this is a cost-bearing generative tool. The description adds the per-image pricing, which is useful operational context beyond the annotations, and clarifies the create-vs-edit behavior. But it doesn't disclose how the presence/absence of the image parameter changes behavior, default aspect ratio handling, or output characteristics.

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?

A single sentence that front-loads the core purpose (create or edit) and tucks cost at the end. Every element earns its place with no 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 3-parameter generative tool with no output schema, the description covers the two key modes but omits the image↔prompt conditional behavior and any return-format guidance. With a large set of closely overlapping siblings, more context on how this image tool differs from ai_image_generator 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 67%, so the schema documents prompt and image, with aspect_ratio fully enumerated. The description adds modest semantics by clarifying that prompt means either 'what to create' or 'how to edit', which maps directly to the prompt parameter. It does not explain the conditional relationship (image present → edit, absent → create), which would meaningfully enrich parameter understanding.

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

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

States a clear verb+resource ('generate' an image) and distinguishes two operating modes: creation from a text prompt and editing with an input image. However, it does not differentiate from the sibling 'ai_image_generator' or 'ai_image_editor', which likely share nearly identical purpose, so an agent cannot tell them apart from the description alone.

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

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

No guidance on when to use this tool versus the many overlapping siblings (ai_image_generator, ai_image_editor, ai_image_expander). No exclusions, prerequisites, or decision criteria are provided. The only extra signal is the $0.10-per-image cost note, which is operational, not usage guidance.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds useful behavior: it returns output_url or output_text once status is 'completed'. However, it does not disclose what happens before completion, what statuses exist, or whether polling is expected, leaving some behavioral ambiguity.

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

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

Two tight sentences with no filler. The core action is front-loaded, and the return condition is stated immediately. Every sentence earns its place.

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

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

For a simple one-parameter status tool with readOnly annotations, the description is nearly complete. The only notable gap is the lack of explicit detail about intermediate states or retry/polling behavior, but the description gives enough for an agent to call and interpret the result correctly in the common case.

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 generation_id. The description adds marginal value by noting that generation_id comes from the asynchronous tool that started the generation, but it does not need to compensate for any undocumented parameters.

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

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

The description states a specific verb ('Check the status'), a clear resource ('a generation started by any asynchronous RegiAI tool'), and the key output condition. This is unambiguously distinct from the sibling generation tools, which start work rather than retrieve results.

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

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

The description clearly implies when to use it: after an asynchronous RegiAI tool has been started, passing the returned generation_id. It does not explicitly name exclusions or alternatives, but none are needed because this is the designated polling/status tool among the listed 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?

The description clearly discloses that execution is asynchronous, returns a generation_id, and requires polling get_generation until status becomes 'completed'. It also adds pricing and GIF duration limits. These are meaningful behavioral details beyond 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?

Two sentences with no filler. The first sentence gives the core purpose, and the second packs cost, limits, async behavior, and next-step instructions efficiently.

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

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

The description covers the essential async flow and how to retrieve the result, which is especially valuable since there is no output schema. It is slightly incomplete because the 'gif' parameter's acceptable input format is left ambiguous, but overall an agent can select and invoke the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds pricing and max duration context, but it does not clarify the 'gif' parameter's accepted input format or add deeper meaning beyond the schema's minimal 'GIF' label.

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 ('Swap faces') and the exact resource ('in GIFs'), distinguishing it from image-only face swaps and other video/animation tools. It also mentions the async result, so an agent immediately knows what to expect.

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

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

The description implies the tool is for GIF face swapping and gives the follow-up step of calling get_generation, but it does not explicitly state when to choose this tool over siblings like face_swap, multiple_face_swap, or ai_face_swap_video. There is workflow guidance, but no alternative tool-fencing.

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 read-only and open-world behavior, so the description does not need to restate safety. It does add useful context by disclosing the $0.01 per-image cost. However, it does not mention output format, supported image types, size limits, or other behavioral caveats.

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 tight two-sentence definition with no filler. The core purpose is front-loaded and the pricing detail is a concise, high-value addition.

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

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

For a simple one-parameter tool, this is mostly adequate, but it lacks an explicit statement about the return value (e.g., the extracted text string) and possible edge cases such as unreadable or low-quality images. The annotations cover safety, but without an output schema, a little more behavioral detail 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?

The schema already describes the single image parameter as 'a public https URL or a base64 data URI' with 100% coverage. The description adds no additional parameter-level meaning, so it appropriately rests at the baseline.

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

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

The description clearly states the operation: 'Extract all readable text from an image.' Combined with the title 'Image to text (OCR)', this is a specific verb+resource pair that distinguishes it from sibling tools like describe_image or ai_speech_to_text.

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

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

No explicit guidance is given about when to use this tool versus alternatives such as describe_image, analyze_image, or ai_speech_to_text. The intended use is implied by the description but not stated, and no exclusionary conditions or alternative routing 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?

The description discloses asynchronous execution, the returned generation_id, and the required polling pattern until status is 'completed'. It also mentions cost ('from $0.50'), which is a valuable side-effect detail not present in 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 very concise and front-loads the core function. The 'from $0.50.' fragment is slightly abrupt but minor; every sentence earns its place and the overall structure is effective.

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 3-parameter tool with full schema coverage, the description captures the non-obvious asynchronous workflow and provides a clear retrieval path via get_generation. It does not describe error handling or exact response format, but the polling instruction makes the flow sufficiently complete.

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

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

The input schema has 100% parameter description coverage, including enum values for duration, so the schema carries the documentation burden. The tool description adds no additional parameter-specific meaning, so the baseline score of 3 is appropriate.

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

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

The description clearly states the primary function ('Animate any photo') with a specific verb and resource. However, it does not differentiate from siblings that also animate photos, such as ai_talking_photo or ai_face_swap_video, so the purpose is clear but not distinguishing.

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

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

It implies the use case: animate a photo, and gives explicit operational guidance to poll get_generation until status is 'completed'. It does not state when to prefer this over related tools or when not to use it, leaving some ambiguity.

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

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

Beyond annotations (readOnlyHint=false, openWorldHint=true), the description adds significant behavioral context: it is asynchronous, returns a generation_id, requires polling get_generation until status is 'completed,' and costs $0.35 per photo. This is valuable operational information not available in the structured fields, and it does not contradict any 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 three concise sentences with no wasted words. It front-loads the core purpose ('Swap several faces in one photo'), then adds cost and async behavior. Every sentence earns its place, and the structure is easy to scan.

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 async nature and absence of an output schema, the description adequately explains the return pattern (generation_id + polling). It does not explicitly mention that only face_1 and face_2 are required while face_3/face_4 are optional, nor does it mention the consent requirement, but the schema covers those. The description is complete enough for an agent to invoke and poll the tool correctly.

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

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

The input schema has 100% description coverage, so each parameter is already well-documented. The description adds no parameter-level meaning beyond the schema, which keeps it at the baseline of 3. It does not explain the roles of face_1 through face_4, group_image, or consent, but the schema already covers those.

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

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

The description states a specific verb and resource: 'Swap several faces in one photo.' The qualifier 'several' clearly distinguishes it from the single-face sibling face_swap and other face-editing tools. An agent can immediately determine this is for multi-face replacement, not for single swaps, video, or GIF variants.

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 multi-face swaps by saying 'several faces,' which hints at when to use it, but it does not explicitly name alternatives or say 'not for single face swap.' It gives an async usage pattern with get_generation, which is helpful, but lacks explicit exclusionary guidance relative to the many 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?

The annotations already declare readOnlyHint=true, so the description does not need to restate safety. It adds useful behavior detail by specifying the output is the remaining balance in USD, and the openWorldHint annotation aligns with the notion of querying current balance. No contradictions found.

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 sentence that places the primary action and resource first. Every word contributes to the tool's meaning without unnecessary elaboration.

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

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

For a parameterless, read-only balance lookup, the description is complete: it states what is returned, in what unit, and for which scope. There is no output schema, but the description sufficiently conveys the return value for an agent to invoke the tool correctly.

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

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

The tool has zero parameters and the input schema confirms this with 100% coverage, so there is no parameter meaning left to explain. The description correctly focuses on what the tool returns rather than inventing parameter details.

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

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

The description clearly states the verb ('Return'), the specific resource ('RegiAI credit balance'), and the unit ('in USD') along with the scope ('for this API token'). It is immediately distinguishable from all sibling tools, which are media generation and manipulation tools.

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

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

The description gives clear context: use this tool to check the remaining credit balance associated with the current API token. It does not explicitly mention when not to use it or name alternatives, but no sibling tool serves a similar purpose, so the usage context is sufficiently 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 readOnlyHint=true and openWorldHint=true, the safety profile is covered by annotations. The description adds behavioral context beyond the annotations: it promises an exhaustive listing ('every tool'), categorizes the catalog by media type, and discloses that prices are included. This is useful but does not go into gotchas like pagination or formatting.

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?

A single, front-loaded sentence that contains only essential information: what is listed, the scope, and what fields are included. No filler or redundant restatement of the tool name.

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

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

For a no-parameter listing tool with no output schema, the description fully conveys what the agent should expect: a list of tools with inputs and prices. There are no extra parameters, side effects, or complex return structures to document. The description is complete.

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

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

The tool has zero parameters, so the baseline is 4. The description correctly implies no inputs are needed by saying 'List every...', and the input schema confirms an empty object. Nothing more is needed here.

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

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

The description states a specific verb ('List'), a clear resource ('every RegiAI tool'), and the exact scope ('image, video, audio') plus the fields returned ('inputs and price'). The title reinforces this. It is instantly distinguishable from the sibling tools, which are individual operations rather than a catalog.

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 use case is implicitly clear: call this tool when you need to discover the available RegiAI tools and their pricing. It does not explicitly name alternatives or state when not to use it, but there is no close sibling that competes with this listing behavior, so the context is sufficient.

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

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

The description adds cost information ('$0.10 per image') and output type ('transparent PNG') beyond the annotations, which only state readOnlyHint=false and openWorldHint=true. This is meaningful behavioral context that the agent needs to decide whether to invoke the tool. However, it does not disclose potential failure modes or edge cases, so it is not a full disclosure.

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

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

The description is two short sentences, front-loaded with the core action and output, followed by the cost. Every word adds value; there is no redundancy or filler, making it 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?

With no output schema, the description correctly specifies the return format ('transparent PNG') and includes the cost, which is essential for agent decision-making. Since the tool has only one parameter already documented in the schema, the description covers all necessary context for an agent to call it correctly.

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

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

The input schema already fully describes the sole parameter ('image' as a public https URL or base64 data URI) with 100% schema description coverage. The tool description adds nothing about parameter usage or format, so it does not surpass 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 action ('Cut out the subject'), the resource (input image), and the output ('return a transparent PNG'), which precisely differentiates it from siblings like remove_watermark. The verb and resource are 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 gives no explicit guidance on when to use this tool versus alternatives. It does not mention conditions or exclusions, nor does it reference any sibling tools. While the purpose implies usage for background removal, the lack of any comparative context leaves the agent to infer the appropriate scenario.

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=false and openWorldHint=true, so the description isn't responsible for those. It adds only the per-image cost, but fails to disclose output format, reversibility, or any side effects beyond billing, leaving significant behavioral gaps uncovered for a tool that modifies images.

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 concise sentence stating the action followed by a brief cost note. There are no wasted words, and the core purpose is front-loaded.

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

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

For a simple one-parameter tool with no output schema, the description states the action and cost but omits return value format (e.g., URL vs. base64) and any constraints like image limits. It's minimally complete but leaves an agent to infer important operational details.

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

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

The input schema provides 100% coverage for the single 'image' parameter, including format options (public URL or base64 data URI). The description adds no parameter-specific details, so the baseline score of 3 applies.

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

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

The description states a specific verb ('Remove') and concrete resources (watermarks, logos, overlaid text), making it easy to distinguish from sibling tools like remove_background or restore_photo. The pricing note is extraneous but doesn't obscure the purpose.

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

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

The description implies when to use the tool through its function statement, but it does not explicitly mention when to prefer this over alternatives or provide any exclusions. No sibling tools are referenced, leaving usage guidance implicit rather than 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?

Annotations already indicate the tool is not read-only (readOnlyHint=false) and may have external effects (openWorldHint=true). The description adds the cost factor ($0.10 per image), which is useful, but it does not disclose output format, side effects, or any other behavioral traits. No contradiction with annotations.

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

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

The description is exceptionally concise—a single sentence plus a pricing note—with no wasted words. The core purpose is front-loaded, and the cost is appended as a distinct, clear piece of information.

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

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

For a simple tool with a single parameter and no output schema, the description is mostly sufficient. It lacks an explicit statement of the output (e.g., 'returns a repaired image'), but this is strongly implied. The cost and purpose are clear, making it adequate for correct invocation.

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

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

The input schema fully describes the image parameter (public https URL or base64 data URI) with 100% coverage. The description adds no additional parameter semantics beyond implying the image is the photo to repair, which is already evident from the schema.

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

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

The description states a specific verb ('Repair') with a clear resource ('scratches and damage in old photos'), which distinguishes it from sibling tools like unblur_image or upscale_image. The purpose is immediately understandable.

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

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

The description implies the tool is for repairing old photos but does not explicitly state when to use it over alternatives, nor does it mention any exclusions or conditions. Usage context is inferred rather than 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?

The description discloses key behavioral traits beyond the annotations: it is asynchronous, returns a generation_id, and requires polling. It also mentions the starting cost. The annotations only indicate this is a write operation with open-world semantics, so the description adds meaningful behavioral context. It doesn't cover failure modes or rate limits, but the async handoff is the most critical behavior.

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

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

The description is concise (two sentences) and front-loaded with the primary action. The async polling note is essential and placed right after. The cost mention ('from $0.50') is slightly extraneous but short and could be relevant for cost-sensitive agents. No padding or redundancy.

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

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

Given the moderate complexity (3 params, one required, no output schema), the description covers the essential runtime contract: async generation and polling. It doesn't explain return values, but it points to get_generation. Authentication/credit requirements are not mentioned, but the cost hint partially covers that. Overall, an agent has enough to invoke and complete the workflow.

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 parameters already have clear descriptions. The tool description does not add any extra parameter detail beyond what the schema provides. It implies the prompt is the main input, but that's already explicit. Baseline 3 is appropriate because the schema does the heavy lifting.

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 core function: 'Turn a prompt into a video.' This specifies the verb, resource, and input type, distinguishing it from image-based tools like image_to_video. However, it does not explicitly differentiate it from the similar sibling ai_video_generator, so it lacks full sibling differentiation.

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 operational guidance: it explains the asynchronous flow, instructing the agent to call get_generation until status is 'completed.' This tells the user exactly how to consume the result. It doesn't explicitly mention when to choose this over alternatives, but the text-input basis and async pattern are strong implied usage signals.

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 indicate readOnlyHint=false and openWorldHint=true, so the description carries the burden of behavioral disclosure. It doesn't state that the operation is irreversible or what changes are made to the image, but it does reveal a cost ($0.05 per image), which is useful contextual behavior. It doesn't mention output format or rate 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 extremely concise, with only two sentences. It front-loads the core action ('Sharpen a blurry photo') and includes the cost as a key decision factor. No wasted words; every bit adds value.

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

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

Given the tool's simplicity (one parameter, no output schema), the description is fairly complete. It states what it does, the cost, and the input format is in the schema. It could be slightly enhanced by mentioning that the output is a processed image, but that's implied. The lack of alternatives is a minor gap.

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

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

The schema covers 100% of parameters with a clear description of the 'image' parameter (public URL or base64 data URI). The description doesn't add extra meaning beyond what's in the schema, but the schema is sufficient, so the baseline of 3 is appropriate. Cost is mentioned but not parameter-specific.

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

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

The description states a specific verb ('Sharpen') and resource ('blurry photo'), clearly indicating the tool's purpose. It distinguishes from siblings like upscale_image and restore_photo by focusing on sharpening rather than resolution enhancement or restoration, though it doesn't explicitly name alternatives.

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

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

The description gives clear context for when to use it (for blurry photos) but doesn't explicitly state when not to use it or mention alternatives. It leaves it to the agent to infer that other tools like upscale_image might be for different kinds of image quality issues.

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 adds a meaningful behavioral detail beyond the annotations: '$0.03 per image.' It also states the transformation effect. However, it does not disclose output format, processing time, or side effects, and the annotations are minimal, so the transparency is adequate but not rich.

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 efficient sentence with no filler, plus a cost note. It is appropriately terse for a one-parameter tool, though it 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?

With no output schema, the description should explain what the caller receives, such as an upscaled image URL or file. It only states the transformation and price, and it lacks usage guidance, so an agent must infer the full contract from the name and 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 description coverage is 100%, so the input schema already documents the image parameter fully. The description does not add format, size, or URL guidance beyond what the schema provides, placing it at the schema-covered baseline.

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

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

The description clearly states the operation: 'Increase image resolution and detail.' This is a specific verb and resource, but it does not differentiate from siblings like unblur_image, ai_image_expander, or ai_video_upscaler, so it loses a point for missing sibling distinction.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. The only signal is the tool name and the generic statement of what it does, which leaves the agent to infer when it is the right choice.

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