AetherWave Studio

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

Annotations already declare readOnlyHint and openWorldHint, so the safe-read nature is covered. The description adds useful context about video generation costs (30-300+ credits) which helps the agent anticipate financial checks. It does not describe return format, but that is less critical given the simple resource.

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 redundancy. The main purpose is front-loaded, and the second sentence adds actionable usage guidance. Every word serves a purpose.

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

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

For a zero-parameter, read-only balance tool with no output schema, the description fully covers what it does and when to use it. The cost guidance for video fills the only needed contextual gap. No missing behavior is apparent.

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 zero parameters, so the baseline of 4 applies. The description needs to explain no parameter semantics; it correctly focuses on the return value and usage 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 'Returns the current AetherWave credit balance for the API key' with a specific verb and resource. It distinguishes from sibling generation/editing tools by focusing on a read-only balance check.

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

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

Explicitly instructs 'Use this BEFORE a generation to confirm sufficient credits', providing a clear when-to-use context. The video cost range (30-300+ credits) further guides priority usage without needing to name alternatives, as no sibling tool offers balance checking.

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 behavioral details beyond annotations: 'Submits, polls, and returns the edited image URL(s)', cost (6 cr per call), number of variations (2), expected latency (~30s), and the upstream URL-spaces/parentheses failure caveat. These are not captured by the annotations, which only state readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false, so the description adds substantial transparency.

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

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

The opening paragraph is front-loaded and direct, with useful examples. The model selection guide is lengthy but well-organized and earns its place given the number of model choices; a small redundancy (default model restated) prevents a perfect score.

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

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

Given 9 parameters, no output schema, and a complex multi-model decision, the description is remarkably complete: it covers return values (edited image URLs), polling behavior, costs, timing, source URL constraints, and model-specific guidance. It is sufficient for an agent to select and invoke the tool correctly in most scenarios.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds extra meaning by explaining model trade-offs (cost, speed, quality), noting that `imageUrl` must be a 'clean URL', and describing default model behavior. It doesn't deeply elaborate every parameter (e.g., `quality`, `renderingSpeed`), but it compensates beyond the schema for the most important ones.

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

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

The description opens with a specific verb+resource: 'Edits an existing image guided by a text prompt.' It then gives concrete examples ('add a moon to the sky', 'swap the background for a neon city') and clarifies required inputs (`imageUrl` plus `prompt`), which clearly distinguishes it from siblings like `aetherwave_generate_image` or `aetherwave_remove_background`.

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

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

It provides an explicit model selection guide with when-to-use rules ('Need a single deterministic output... -> seedream-v4-edit', 'NSFW edits -> wan-2.5-spicy-i2i') and a default fallback ('If the user simply says "edit this image"... default to grok-imagine-i2i'). It also directs users to `list_image_models` for the full lineup, offering clear 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?

Goes well beyond annotations by disclosing job submission/polling, credit costs, output counts, adult-content routing, and provider aspect-ratio requirements. The description is consistent with readOnlyHint=false and destructiveHint=false, so there is 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?

The description is long but appropriately structured: front-loaded purpose, then model selection guide, I2I alternatives, and user-confirmation conditions. Every section earns its place given the tool's complexity and 8 parameters.

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

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

Even without an output schema, the description explains the return value (final image URLs), job lifecycle, credit costs, and when to ask for user input. This is a complete and actionable description for a complex generative media tool.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds meaningful context: default model behavior, model selection guide, explicit aspectRatio advice, referenceImages single-URL convenience, and numImages usage. It does not add much for seed or negative_prompt, but those are already well-described in the schema.

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

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

The description clearly states it generates one or more images from text (T2I) or text plus reference image(s) (I2I), and explains the job lifecycle (submit, poll, return URLs). It distinguishes itself from sibling tools like aetherwave_edit_image and other media generation tools by explicitly covering image generation and model selection.

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

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

Provides explicit when-to-use and when-not-to-use guidance: prefer aetherwave_edit_image for editing, use I2I models only for specific intents, use list_image_models for full lineup, and includes concrete model selection criteria by prompt signals. It also specifies when to ask the user for clarification.

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

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

Discloses non-obvious behaviors beyond annotations: two tracks returned, default model, 6-minute polling budget, advisory title for instrumentals, and common transient errors with retry strategy. This is rich behavioral context.

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

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

The description is concise: four sentences, every one adding operational value. It front-loads the main action and then packs specifics efficiently 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?

With no output schema, the description mentions two tracks but not the response structure. However, it covers timing, errors, defaults, and key parameter nuances, which is a strong level of context for a complex generation tool. Missing only formal return format details.

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

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

Schema already describes all parameters with 100% coverage, so baseline is 3. The description adds extra semantics for the instrumental param and notes about title behavior, plus retry guidance, which is additional value over the schema.

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

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

The description clearly states it generates AI music via Suno, using a specific verb and resource. It distinguishes itself from sibling tools by naming music generation specifically and adds unique details like returning two tracks per submission.

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

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

Provides clear operational context: instrumental flag, polling duration, retry behavior. However, it does not explicitly compare to alternatives or state when not to use this tool, falling short of full exclusion 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?

Beyond the annotations (which only indicate non-read-only, open-world, non-idempotent, non-destructive), the description discloses critical behavioral traits: it submits and polls with an up-to-8-minute budget, default fallback to fal.ai, cost surcharges for audio on Kling models, and the fact that resolution/duration drive cost more than model choice. It also mentions auto-tagging for NSFW. 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 long, but every section earns its place: the opening paragraph is a clear summary, and the model selection guide is well-structured with terse bullet lines. It is front-loaded with the core behavior. It could be slightly tightened by moving the cost guide elsewhere, but the structure is logical and scannable, making it more genuinely useful than verbose.

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

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

Given the tool's complexity (8 params, many model choices, no output schema), the description is remarkably complete. It explains the return value (final video URL), poll timing, model selection criteria, cost pitfalls, and when to ask the user. The absence of an output schema is compensated by the explicit mention of the returned URL and the polling behavior.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds meaningful context beyond the schema: it notes imageUrl is required for I2V models, endImageUrl is for first+last-frame models, duration constraints per model (e.g., Grok accepts 6-15s), and cost implications of resolution/duration choices. It does not systematically walk through every parameter but enriches the most decision-critical ones.

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

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

The description opens with a specific verb+resource: 'Generates a short-form video from a text prompt (T2V) or a text prompt + starting image (I2V).' It clearly distinguishes itself from sibling tools like aetherwave_generate_image and aetherwave_generate_music by focusing exclusively on video generation, and further clarifies T2V vs I2V modes.

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 an extensive, explicit model selection guide with concrete conditions ('highest quality', 'fast premium', 'cinematic camera moves', etc.) and names alternative models like veo3.1-quality, seedance-pro-t2v, and wan-2.7-t2v. It also states when to ask the user (e.g., cost >100 credits) and when to use list_video_models, giving clear decision boundaries.

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

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

Annotations already declare readOnlyHint=true, and the description adds behavioral detail about the returned fields (credit cost, aspect ratio, inputs, options) and how the model key is used downstream. It does not mention rate limits or pagination, but the tool is a simple list with zero parameters, so the added context is sufficient.

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

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

Two sentences with no redundancy. The first sentence front-loads the main purpose and return fields; the second sentence gives actionable usage guidance. 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?

Given zero parameters and no output schema, the description fully covers what the tool returns, how to use it, and why it matters. It is complete for its purpose and requires no further elaboration.

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 schema coverage is trivially 100%. The description adds value by explaining that the returned model key is what you pass to generate_image, which clarifies the connection to another tool's parameter even though this tool itself has no inputs.

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

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

The description clearly states that the tool returns every image-generation model AetherWave supports, listing specific fields (credit cost, aspect ratio, input types, options). It distinguishes itself from sibling tools like aetherwave_list_video_models by explicitly focusing on image models.

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

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

The description explicitly says 'Call this before generate_image when you don't know the right model ID', giving a clear when-to-use directive and tying it to a sibling tool. It also implies that generate_image is the consumer of the model key, providing practical 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 declare readOnlyHint=true and openWorldHint=true. The description adds valuable context about the return contents (12 presets, style coverage, LUFS examples) that goes beyond the annotations. It does not contradict the read-only nature, though it does not discuss potential rate limits or caching, which are minor for a list operation.

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

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

The description is compact (four sentences) and front-loaded with the primary action. Every sentence earns its place: returns what, when to use, how many and which styles, and LUFS examples. 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?

Despite having no output schema, the description explains the return values (target LUFS, tags, descriptions, difficulty level) and provides concrete examples. It also covers usage context and breadth of presets, making it fully sufficient for an agent to understand 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?

The tool has zero parameters, so the baseline is 4. The description correctly says nothing about parameters, and the empty schema needs no further explanation. No additional parameter semantics are required.

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

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

The description clearly states the tool's function: 'Returns every AI mastering preset AetherWave supports' with specific fields (target LUFS, tags, descriptions, difficulty level). It distinguishes this listing tool from the mastering tool (master_audio) and other sibling list tools by focusing on audio mastering presets.

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

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

Explicit guidance is given: 'Call this before master_audio when you don't know which preset fits the track.' This names the alternative tool and specifies the condition for use, which is exactly the level of when-to-use guidance expected.

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=true), the description discloses pagination support, type filtering, and the exact fields returned including type-specific fields. This gives agents a complete picture of the return payload and behavior without an output 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 front-loaded with the main purpose and includes useful examples. The field list is somewhat lengthy but serves as a substitute for an output schema, so it 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 read-only list tool with no output schema, the description sufficiently explains the return fields, filtering, and use cases. It is complete enough for an agent to invoke correctly without additional context.

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

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

Schema coverage is 100%, with each property already documented. The description only restates that pagination and type filtering are supported, adding no extra meaning over the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool returns gallery items from the authenticated user, listing exact media types (images, videos, audio). It distinguishes itself from sibling generation/edit tools by being the listing tool for user creations.

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

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

The description provides explicit example workflows ('find my last 5 images and reframe them', 'list my recent songs and master each one'), indicating when to use this tool before editing. It lacks an explicit 'when not to use' but there are no sibling listing tools, so context is clear.

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

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

Annotations already declare readOnlyHint=true, and the description adds valuable behavioral context by listing the exact data fields returned (credit cost, durations, resolutions, aspect ratios, I2V requirement). This goes beyond the safety hint and helps the agent anticipate the response shape.

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 filler. The first sentence packs the output details and examples; the second sentence provides usage context. 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?

With no parameters and no output schema, the description fully compensates by detailing both purpose and return content. It also gives usage context, making the tool self-sufficient for an 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?

Tool has 0 parameters, so baseline is 4. The description doesn't need to explain parameters; it instead focuses on output, which is appropriate for a zero-argument tool.

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

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

The description clearly states the tool's function: returning every video-generation model with specific attributes. It distinguishes itself from sibling tools like list_image_models by explicitly focusing on video models and mentioning generate_video in usage.

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

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

Provides explicit usage guidance: 'Call this before generate_video when you don't know the right model ID.' This tells the agent exactly when to use the tool and implies the alternative (skip if model ID is already known).

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

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

The description adds substantial behavioral detail beyond annotations: synchronous polling ('route polls the Python service internally; expect 30s-5min'), cost ('20 credits per track'), free plan tiers, and output specifics ('WAV (~50MB per 3-minute track, lossless for redistribution)'). These are critical operational facts not present 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?

The description is front-loaded with the core purpose and then packs in relevant operational details (timing, cost, output, presets). While it is long, every sentence carries useful information, though it could be tightened slightly without losing 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?

For a tool with no output schema and 3 parameters, the description is remarkably complete: it covers synchronous behavior, latency, cost, free plans, output format and size, lossless quality, and preset guidance with a pointer to a sibling tool for the live list. The agent has enough context to invoke it correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning by explaining that the preset 'steer[s] the mastering style' and that each preset's target LUFS lets you 'match the distribution target,' which goes beyond the schema's mere enumeration. However, much of the parameter detail is redundant with the schema.

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

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

The first sentence clearly states the action and resource: 'Submits an audio file for AI mastering and returns the mastered URL synchronously.' It distinguishes the tool from siblings by positioning it as a 'final polish step after music generation' and by referencing aetherwave_list_master_presets for preset selection.

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

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

Provides clear context by stating it is 'Useful as a final polish step after music generation,' which implies when to use. It also gives practical constraints like audio URL requirements, expected wait time, and cost, but does not explicitly name alternatives or state when not to use.

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

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

The description discloses key behavioral details beyond annotations: it performs outpainting, has three speed tiers with specific credit costs, and returns a new image URL. It does not contradict annotations (readOnlyHint=false, etc.) and adds useful cost/performance trade-off information. Minor gaps remain about side effects or rate limits, but for a creative tool this is solid.

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, front-loaded with the core purpose and then providing the essential parameter and return information. Every sentence earns its place with no fluff 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 tool with only 3 parameters and no output schema, the description covers the main functionality, inputs, speed/cost options, and return value. It does not mention limitations like max file size or file format restrictions, but given the openWorldHint and simple nature, the description is nearly 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 covers all three parameters with 100% description coverage, including the enum values and credit costs. The description reinforces the aspect ratio examples and speed tiers but adds no new parameter-specific meaning beyond what the schema provides, 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 a specific verb ('Reframes') and a specific resource ('image') with a clear goal ('to a new aspect ratio'). It distinguishes itself from siblings like reframe_video and edit_image by focusing on image reframing via outpainting.

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 the tool (when needing to reframe an image to a new aspect ratio) and explicitly lists the required inputs and speed options. It does not explicitly name alternatives or state when not to use it, but the sibling list and specific language make the usage context 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 indicate readOnlyHint=false and destructiveHint=false, but the description adds valuable behavioral context: cost (17 credits per second), output format (R2-hosted URL), and the outpainting/cropping mechanism. It also clarifies that the source must be a public URL. No contradiction with annotations; this is a solid disclosure of operation 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 three sentences, front-loaded with the primary action, and every sentence adds meaningful info: operation, required inputs, optional prompt with example, cost, and return format. There is no fluff or redundancy, making it highly efficient 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?

The tool has no output schema, so the description's mention of 'Returns the reframed video URL (R2-hosted)' fills that gap. It covers purpose, inputs, optional parameter, cost, and output. It could additionally note potential processing time or failure modes, but the provided information is sufficient for an agent to decide to invoke the tool. Sibling tools are similar but not referenced, yet the context is complete for a typical use 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 all three parameters. The description adds marginal value by giving an example for reframePrompt and emphasizing videoUrl must be public, but this is largely redundant. Baseline 3 applies because the schema does the heavy lifting; the description does not significantly enhance parameter understanding.

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

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

The description clearly states the tool's purpose: 'Reframes a video to a new aspect ratio by intelligently outpainting/cropping the edges.' It uses a specific verb ('reframes') and resource ('video'), and the mention of 'video' distinguishes it from the sibling reframe_image tool. The title also adds model context (Luma Ray 2 Flash), reinforcing the specific 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 clear context for when to use the tool: to change a video's aspect ratio via outpainting/cropping. It specifies required inputs (public videoUrl and reframeAspectRatio) and optional reframePrompt. However, it does not explicitly compare to alternatives or state exclusions (e.g., 'use reframe_image for images'), though sibling tooling implies this. This is a minor gap, so 4 is appropriate.

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 costs (~5 credits per image), provider fallback behavior (Recraft to fal.ai BiRefNet v2), and failure semantics ('single-image calls never silently fail'). It also addresses edge cases like transparent-PNG inputs, all beyond the sparse annotations. No contradictions with annotations.

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

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

The description is compact and front-loaded with the primary action, followed by key context (cost, fallback, limitations). Every sentence provides value without redundancy or verbose explanation.

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

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

Despite having no output schema, the description specifies the return format (PNG with transparent alpha). It covers costs, provider fallback, ideal use cases, and a limitation, making it complete for a single-parameter tool.

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

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

The schema already fully describes the only parameter with 'Public URL of the source image' and format uri. The description repeats 'Pass a public `imageUrl`' without adding new semantic detail, so it meets the baseline for high schema coverage but does not improve on it.

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

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

The description opens with 'Strips the background from an image, returning a PNG with transparent alpha,' clearly stating the verb, resource, and outcome. It distinguishes itself from siblings like aetherwave_remove_background_video by explicitly targeting images and noting the fallback to BiRefNet v2.

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 explicit use cases ('product shots, character cutouts, logo isolation...') and a clear when-not-to-use ('transparent-PNG inputs have no foreground to segment'). However, it does not explicitly name an alternative tool for video or editing, relying on sibling names rather than direct comparison.

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, the description adds cost (2 credits/second), performance expectations (6s clip ~4 min), limitations (clear edges), and return format (R2-hosted URL). This significantly enriches the behavior profile without contradicting 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 a single, dense paragraph with no filler. It front-loads the purpose and progressively provides options, cost, performance, and output. Each clause adds distinct value.

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

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

Covers the full lifecycle: input requirements, processing method, output format, cost, and performance caveats. Even without an output schema, it tells the agent what to expect (R2 URL). Given the tool's complexity, this is remarkably 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 defines all three parameters with descriptions (100% coverage), but the description adds relational meaning: it explains how bgType and customColor interact (transparent vs color replacement) and specifies the output format (alpha WebM). This goes beyond the schema's individual descriptions.

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

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

The description opens with a specific verb ('Strips') and resource ('the background from a video'), clarifying the frame-by-frame methodology using rembg. This clearly distinguishes it from siblings like aetherwave_remove_background (image-focused) and other video 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?

Provides clear context on when to use it ('Works best on subjects with clear edges') and warns about performance ('Slowest tool in the surface') with concrete timing examples. It does not explicitly name alternatives or exclusion scenarios, but the context is strong enough for an agent to decide.

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

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

The description adds useful behavior beyond the annotations: credit cost depends on source resolution × factor, and it returns the upscaled image URL. Annotations already indicate non-readonly, non-idempotent, non-destructive, and open-world, and the description does not contradict them. It could mention side effects or limitations, but the cost model is valuable.

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, front-loaded sentences: purpose, usage, and cost/return. 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?

With only 2 simple parameters and no output schema, the description fully covers inputs, output, and cost behavior. It is complete for the tool's complexity and provides enough context for correct invocation.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds extra meaning by explaining that credit cost is a function of resolution and factor, which helps choose parameters. It also reiterates the need for a public URL, aligning with the schema's format.

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

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

The description starts with a specific verb 'Upscales' and a clear resource 'source image', also naming the technology 'Topaz's high-fidelity upscaler'. This clearly distinguishes it from sibling tools like aetherwave_upscale_video or aetherwave_edit_image.

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

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

It gives clear instruction to pass a public imageUrl and upscaleFactor, and provides cost guidance based on resolution and factor. It doesn't explicitly mention alternatives or exclusions, but the image-specific language and sibling tool names make the intended use clear.

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

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

Beyond the basic annotations, it discloses per-second costs, Atlas-side limits (clip length, frame rate), and that the result is an R2-hosted URL. This adds meaningful behavioral context about what the tool does and its constraints.

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

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

Four focused sentences cover function, usage, cost/limits, and return value. No redundancy or irrelevant details. The structure is front-loaded with the primary 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 description covers input, constraints, cost, and output URL, which is sufficient given no output schema. It could mention failure behavior but that's not essential. The limits and cost give good operational context.

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

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

The schema covers 100% of parameter descriptions, so the description doesn't need to add much. It restates videoUrl and targetResolution without adding new semantics beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description clearly states the tool upscales videos to 1080p or 2K using Atlas, with a specific verb (upscales), resource (video), and target resolutions. It distinguishes itself from sibling tools like aetherwave_upscale_image and aetherwave_generate_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 provides clear context for when to use: upscaling a video with a public URL, with specified resolutions, limits, and costs. It doesn't explicitly name alternatives but the context is sufficient for most AI agents.

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