Ludo AI Game Assets

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

With no annotations, the description carries full burden. It discloses synchronous execution, return format (animation-only GLB with mp4 preview), variability ('Animation quality is hit-or-miss'), credit charging ('once per call... only on success'), and API key requirement. This is far beyond minimal behavioral 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?

Every sentence serves a purpose: purpose, requirements, sync/output, mode, quality caveat, and credits. It is front-loaded with the main action and flows logically. No wasted words or 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?

Despite no output schema, the description thoroughly explains the return value: 'num_variants candidate animations... each a standalone animation-only GLB... in glb_url plus an mp4 preview_url.' It also covers credit cost, synchronization, and model prerequisites. For the tool's complexity, this is a complete and self-contained description.

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

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

Although top-level schema coverage is 0%, the description adds meaning to key parameters: model (rigged GLB URL/base64), prompt (example 'walking'), mode ('rot_trans default, most faithful; rot_only for retargeting'), and num_variants (default 4). It doesn't explain all nested fields, but the nested schema already contains descriptions. The description compensates well for the top-level gap.

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: 'Generate text-driven skeletal animations for an already-rigged 3D model.' This clearly distinguishes it from sibling tools like animate3DModelPreset (preset-driven) and rigModel (rigging, not animating). The scope is well-defined.

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 explicitly states a prerequisite: 'The model must already have a skeleton — rig it first via the rig endpoint if not.' This directly names the alternative tool (rig endpoint) and specifies when not to use this tool. It also explains the workflow of selecting from multiple candidates and fusing them in a game engine or three.js.

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

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

With no annotations, the description carries full burden and does so admirably. It discloses synchronous behavior, the exact response envelope (glb_url, preview_url, same as animate endpoint), credit charging only on success, required API key with user scope, per-call credit cost, and the effect of optional parameters. This is comprehensive behavioral 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 information-dense but remarkably well-structured. It uses concise sentences, separates distinct concepts, and each sentence contributes unique value—from core functionality to prerequisites, return format, parameter behavior, and cost. No fluff 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 no output schema and no annotations, the description is the sole source of behavioral insight. It covers all critical aspects: what it does, prerequisites, synchronous execution, return format, optional parameter behavior, authentication, and credit cost. This is a complete and self-sufficient description for an agent to correctly select and invoke the tool.

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

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

Despite the input schema having descriptions for nested properties, the context signals report 0% coverage for top-level parameters. The description compensates by clearly explaining each parameter: model (URL/base64, already rigged), preset_id (clip_url prerequisite), crop_loop (trimming to loop), in_place (net travel removal), and their relationships (e.g., in_place omits follow crop_loop). This adds substantial meaning beyond the schema.

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

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

The description clearly states the tool's purpose: 'Apply a curated animation preset to an already-rigged 3D model (retargeting).' It specifies the verb (apply), resource (animation preset to 3D model), and distinguishes from siblings like animate3DModel and animateSprite by mentioning 'already-rigged' and 'preset'.

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

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

The description gives explicit context for when to use this tool: requires an already-rigged model with humanoid-template rig, and only presets exposing a clip_url can be applied. It also references the animation presets list and explains the semantics of optional parameters. However, it does not explicitly name alternative tools or state when NOT to use it, so it stops short of full distinction.

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

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

With no annotations, the description fully discloses behavior: synchronous execution with no polling, response contents (spritesheet URL, frame layout, optional GIF/frame URLs), error condition (HTTP 400 for incompatible model/duration), credit charging only on success, and API key requirement. No contradiction 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?

The description is longer than necessary but well-structured, front-loading the core purpose in the first sentence. It covers many valuable aspects (synchronous behavior, alternatives, credits, workflow) without wordiness. The pricing details are redundant with schema, but not excessive.

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

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

Given the tool's complexity, absence of annotations, and no output schema, the description is remarkably complete. It covers input/output summary, synchronous behavior, error handling, credit billing, workflow integration, and auth requirements, leaving few gaps.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by highlighting the core parameters (initial_image, motion_prompt, final_image, request_id) and explaining their roles in the overall flow (e.g., request_id for later retrieval). It also notes the model/duration compatibility constraint, which supplements the schema's per-model duration lists.

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: 'Animate a static sprite into a spritesheet driven by a motion text prompt (image-to-spritesheet)' with specific inputs (initial_image, motion_prompt) and option for final_image. It also distinguishes itself from siblings like animateSpriteKeyframes and transferMotion.

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

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

Explicitly provides when-to-use and alternatives: 'use animateSpriteKeyframes instead' for keyframe-driven animations, 'prefer transferMotion' when copying motion from a reference, and recommends calling generatePose first. This gives clear directional guidance.

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

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

With no annotations provided, the description fully carries the behavioral burden. It discloses synchronous execution with no polling, Forge-only model usage, credit charging only on success with a never-more-than-requested guarantee, and API key requirement. It even summarizes the direct return shape (spritesheet URL, frame layout, optional GIF/individual frame URLs).

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 dense but every sentence earns its place: purpose, keyframe rules, model limitation, sync behavior, pricing, alternative tool, result tagging, and auth. It is front-loaded with the primary purpose and uses short, scannable clauses.

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?

Complexity is high (three keyframes, many optional boolean/numeric parameters, model-specific pricing, no output schema), yet the description covers sync behavior, return contents, model constraint, success-based billing, and result retrieval. It is effectively complete for an agent to invoke correctly.

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

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

Schema coverage is 100% with rich per-parameter descriptions, so the baseline is 3. The prose adds meaning beyond the schema by explaining ordered keyframe interpolation, the anchor rule for final_image, and that omitting motion_prompt drives motion purely from keyframes.

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: 'Animate a sprite through up to three fixed keyframes — initial_image, middle_image and final_image ... producing a spritesheet.' It clearly distinguishes from the sibling animateSprite tool by naming the alternative and the differing scope (keyframes vs single-image + text-prompt).

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 when-to-use and when-not-to-use guidance: the minimum keyframe requirement (initial or middle), the optional motion_prompt behavior, and 'Use animateSprite instead for the classic single-image + text-prompt animation with model choice.' It also notes model constraints and how to retrieve results via request_id/getSpriteResults.

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

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

With no annotations, the description fully carries the behavioral burden. It discloses the synchronous blocking nature, the internal steps (generated, decompressed, re-uploaded), the return payload (GLB URL and snapshot images), credit charging only on success, API key scope, and exact credit cost. This is comprehensive and goes far beyond minimal 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 a single, well-structured paragraph that front-loads the core purpose, then flows logically through behavior, controls, credits, and credentials. Every sentence carries unique information without redundancy, making it both concise 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?

The tool has no output schema, so the description compensates by clearly explaining the return values (GLB model_url and snapshot URLs). It also covers prerequisites, cost, and result retrieval, making it contextually complete for an agent to invoke this tool with confidence.

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?

Though the top-level schema parameter (requestBody) lacks a description, the description explicitly details all nested parameters: target_num_faces with range and default, texture_size with allowed values and default, texture_type with enum and default, and request_id for later retrieval. It adds meaning well beyond the sparse schema descriptions.

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

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

The description clearly states 'Convert a single source image into a textured 3D model (image-to-3D)' with a specific verb and resource. It distinguishes itself from sibling tools like animate3DModel and rigModel by focusing on the creation step, making the purpose unmistakable.

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

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

The description provides context such as synchronous blocking, credit cost, and API key requirements, but it does not explicitly compare with alternatives or state when not to use this tool. It implies usage via the core conversion action and mentions related get3DModelResults for retrieval, but lacks 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?

With no annotations provided, the description carries the full burden and does so excellently. It discloses that the call blocks until generation finishes, returns a single audio result with a URL, has no polling step, charges credits only on success, consumes 2 credits, and requires an API key with user scope.

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 information-dense and well-structured, front-loading purpose and following with behavior and guidance. It is slightly longer than necessary due to a redundant credit mention ('Credits are charged on success' and 'Credits: This endpoint consumes 2 credits per call'), but each sentence otherwise earns its place.

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

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

Given no output schema, the description adequately explains the return value (single audio result with URL), runtime behavior, authentication, credit cost, and relationship to sibling tools. It is complete enough for an agent to 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 some plain-language context (e.g., 0 means auto-pick duration, request_id used to locate results via getAudioResults), but most parameter meaning is already fully documented in the schema, so no significant extra value.

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

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

The description uses a specific verb ('Produce') and resource ('looping background ambiance soundscape from a text description'), with concrete examples. It explicitly distinguishes itself from sibling tools like createSoundEffect, createMusic, and createAudioTransform.

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 when-to-use guidance ('Use this for continuous, atmospheric background loops') and names specific alternatives for other use cases. It also explains the synchronous behavior, duration cap, required description, credits, and API key requirement.

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

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

With no annotations, the description fully carries the behavioral burden and does so thoroughly. It discloses that the call blocks until generation finishes, returns a single audio result with a URL, charges credits on success, requires an API key (user scope), and returns HTTP 400 for oversized samples. It also explains the effect of modification_strength and credit consumption per call.

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 dense but well-organized, starting with purpose, then requirements, then synchronous behavior, then parameter guidance, then alternatives, then result tagging and auth. Every sentence adds value, and the 'Credits' line is a concise separate note. No fluff 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?

No output schema exists, but the description explains the return value (single audio result with a URL) and the synchronous nature. It covers input constraints, auth, credits, alternatives, and result retrieval via getAudioResults, making it complete for a complex tool with nested parameters.

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

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

Schema coverage is 100%, so baseline is 3. The description adds useful behavioral context beyond the schema, such as the HTTP 400 error on oversized samples and the credit charge. It reiterates and clarifies parameter semantics (e.g., duration 0 matches source, modification_strength range and default), which helps the agent invoke the tool effectively, though much is already in the schema.

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

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

The description clearly states the tool remixes an existing audio sample into a variation guided by a text prompt, with concrete examples like '80s synthwave or metal version.' It explicitly distinguishes from sibling tools by noting that createSoundEffect, createAmbiance, or createMusic are for generating audio from scratch, while this tool transforms existing audio.

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

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

Explicit when-to-use guidance is provided: 'Use this to transform existing audio you already have; use createSoundEffect, createAmbiance, or createMusic to generate audio from scratch.' It also lists key prerequisites (sample and prompt required, 15MB size limit, allowed durations, API key) and explains that the call is synchronous with no polling, giving clear operational context.

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

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

With no annotations, the description carries the full burden and does an excellent job. It discloses synchronous blocking behavior, return format (array of URLs), credit charging only on success, and API key requirement (user scope). It also explains the request_id tagging for later retrieval via getImageResults, adding valuable 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 yet packed with essential information. Every sentence serves a purpose: purpose, behavior, variations, credit cost, alternatives, and authentication. It is well-structured with a logical flow from what it does to how to use it to when to use alternatives.

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

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

Given the tool has no output schema, the description adequately covers the return format (array of image results with URLs), synchronous nature, credit cost, authentication requirement, and alternative tools. This is sufficient for an agent to invoke the tool correctly and understand the result structure.

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 extra semantics by explaining how n controls variations (1-8), and how request_id can be used to tag and retrieve results later. It also summarizes the purpose of image_type, art_style, perspective, and aspect_ratio, which goes beyond the schema's field-level descriptions.

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

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

The description clearly states the tool generates game-art images from a text prompt alone, with a specific verb and resource. It distinguishes itself from siblings like generateWithStyle, editImage, and removeBackground by naming them explicitly, making the purpose unambiguous.

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

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

Explicit usage guidance is provided: 'Use createImage to make new images from scratch; use generateWithStyle to match a reference image's art style, editImage to modify an existing image, and removeBackground to cut out a subject.' It also mentions when the tool is not needed (no source image, no upload size limit), which helps in selecting 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?

With no annotations, the description carries full burden and does so comprehensively. It discloses synchronous blocking with a single URL result, no polling step, required field behavior, duration constraints with HTTP 400 for out-of-range, credits charged on success, API key requirement, and the exact credit cost (3 credits). This is exemplary 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?

Despite being moderately long, every sentence earns its place: purpose, behavior, constraints, sibling differentiation, optional tagging, auth, and credits. It is front-loaded with the core purpose and progressively adds operational details without 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?

The tool has one complex nested parameter and no output schema, but the description covers what the agent needs: result format (single audio result with URL), error behavior, credits, auth, and explicit alternatives. The sibling context is well addressed, making this complete for safe and 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%, so baseline is 3. The description adds value by explaining the semantics of duration (0 means auto, multiples of 10 up to 180, out-of-range returns 400) and the purpose of request_id (to locate the result via getAudioResults). This goes beyond the schema's descriptions without fully covering all parameters, but the additions are significant.

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 'produces a piece of music from a text description' with optional lyrics, using a specific verb and resource. It explicitly distinguishes from siblings by naming createSoundEffect, createAmbiance, and createAudioTransform with their different use cases, making the purpose unambiguous.

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

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

The description provides explicit when-to-use guidance: 'Use this for songs and musical scores' and directly contrasts with three sibling tools. It also notes the synchronous behavior (no polling), required description field, and credential requirement, giving clear context for appropriate invocation.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the call blocks (synchronous), returns a URL, has no polling step, charges 2 credits on success, requires an API key, caps duration at 10 seconds, and supports looping. These behavioral details are comprehensive and go 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 well-structured and front-loaded: purpose, behavior, usage, auth, and credits. Every sentence adds value, and there is no extraneous information. It is concise yet thorough.

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

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

Given no annotations and no output schema, the description covers all essential aspects: what it does, how it behaves (synchronous, returns URL), when to use it, prerequisites (API key), and costs. It fully equips 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 coverage is 100%, so baseline is 3. The description adds meaningful context for 'duration' (auto-pick based on description), 'loop' (seamless looping), and 'request_id' (tag and locate via getAudioResults), which clarifies usage beyond the schema's descriptions.

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

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

The description clearly states the tool's purpose: 'Produce a short sound effect (SFX) from a text description' with concrete examples. It also differentiates from siblings by naming createAmbiance, createMusic, and createAudioTransform, making the scope 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?

Explicit usage guidance is given: 'Use this for short, discrete sounds; use createAmbiance for a continuous looping background soundscape, createMusic for musical pieces, and createAudioTransform to remix an existing audio sample.' It also states the synchronous behavior and credit implications, aiding correct tool 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?

With no annotations provided, the description fully discloses behavior: synchronous blocking, single audio result with URL, no polling, credits charged on success, HTTP 400 on violations, auth requirement (API key user scope), and size limits. This goes well beyond the schema and 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 dense but well-organized: purpose first, then requirements, behavior, usage alternatives, optional parameter, and auth. Every sentence adds distinct value without redundancy.

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

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

Despite having no output schema and no annotations, the description covers purpose, parameters, constraints, error behavior, synchronous nature, return format, credits, auth, and alternatives. It is fully sufficient for an agent to 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?

Even though schema coverage is 100%, the description adds critical semantics: text limited to 1000 characters (also max 100 words conceptually), sample must be URL or base64 audio max 15MB, and request_id ties to getAudioResults for later retrieval. These details are not fully present in the schema alone.

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

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

The description opens with a specific verb and resource: 'Convert text to speech by cloning the voice from an audio sample you provide.' It clearly distinguishes this from sibling tools like createSpeechPreset and createVoice, which is reinforced later in the usage guidance.

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

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

Explicitly states when to use this tool: 'Use this when you have a reference voice sample to clone' and names alternatives: 'use createSpeechPreset... and createVoice...' It also covers operational context such as synchronous execution, no polling, and credit charging.

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

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

With no annotations, the description fully discloses behavior: it blocks until generation finishes, returns a single audio result containing a URL, charges credits on success (1 credit per call), returns HTTP 400 for invalid input, and limits text to 1000 characters. It also explains how request_id can be used to locate results later via getAudioResults.

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

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

The description is well-structured and front-loaded, with the main purpose in the first sentence. However, there is minor redundancy: 'Both text and voice_preset_id are required' repeats schema info, and 'Credits are charged on success' is followed by the specific credit count. Overall, it is efficient and organized, but slightly overlong.

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 all essential aspects for a synchronous, billing-affected tool: output format (URL), error handling, authentication, credits, and alternatives. Since there is no output schema, it explains return values adequately. It also references the results endpoint for later retrieval, making it complete 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%, so the baseline is 3. The description adds context like text character limit and that voice_preset_id is a built-in preset, but these are already in the schema descriptions. The request_id explanation mirrors the schema's 'retrieve results later via the results endpoint.' No significant additional parameter semantics are provided.

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 and resource: 'Convert text to speech using a named built-in preset voice.' It also distinguishes from siblings by explicitly naming createSpeech and createVoice as alternatives for cloning or designing voices. The synchronous behavior and return of a URL further clarify what the tool does.

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

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

The description provides explicit when-to-use guidance: 'Use this when you want a ready-made catalog voice and do not need to supply your own sample.' It also names alternatives, states required parameters (text and voice_preset_id), mentions the synchronous nature (no polling), and notes authentication requirements (API key with user scope).

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

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

With no annotations provided, the description carries the full burden. It discloses synchronous blocking behavior, return values (video URL and duration), credit charges only on success, model-duration compatibility returning 400, and API key requirement with user scope. This is comprehensive behavioral disclosure beyond what any schema could imply.

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 longer than average but each sentence provides distinct value: sync behavior, optional interpolation, compatibility constraints, billing, request tagging, and related tools. The structure is logical and front-loaded with the core purpose, and while dense, it remains readable 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?

The description is exceptionally complete for a complex tool. It covers the synchronous execution model, return values, billing details, model/duration compatibility, optional parameters, authentication, and related tools. Without an output schema, it explains what the agent can expect after invocation, including actual duration and video URL. No critical operational aspect appears 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?

The schema already covers all parameters with descriptions and enums, achieving 100% coverage. The description adds valuable cross-parameter context such as final_image interpolation, request_id for later retrieval, and credit cost implications per model. While it doesn't re-explain each parameter, it enriches understanding of their interactions, going beyond the baseline for full schema coverage.

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

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

The description clearly states the tool's function: 'Generate a short video clip from a source image and a motion text prompt (image-to-video)'. It uses a specific verb and resource, and explicitly distinguishes from siblings like createImage and animateSprite, referencing them as alternatives for other tasks.

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 when to use this tool: synchronous behavior with no polling, compatible model/duration choices, credit charging rules, optional request_id for later lookup, and explicitly names related tools for different use cases (createImage for static images, animateSprite for sprite-sheet animation, getVideoResults for listing past results). This fully addresses usage context and alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It covers synchronous execution ('the call blocks until rendering finishes'), error conditions ('incompatible combinations return HTTP 400'), credit charging details ('only on success, based on the produced duration and never more than the duration you requested'), authentication requirements ('Requires an API key'), and the return value (video URL and duration). This is comprehensive.

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

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

The description is about 180 words, which is reasonable given the complexity of the tool (multiple parameters, sync behavior, pricing, related tools). It is front-loaded with the core purpose and differentiation, then details comportment and constraints. While it includes some pricing details that also appear in the schema's model description, the repetition is not excessive and serves to reinforce key usage constraints.

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 all essential aspects required for safe and correct invocation: purpose, differentiation, input format (URLs or base64), sync behavior, return values, error handling, credit costs, authentication, and related tools. Given the lack of an output schema, it adequately describes what the agent will receive (video URL and duration). No major gaps are 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?

Schema coverage is 100%, so the schema already documents each parameter. The description adds cross-parameter relationships not fully in the schema, such as the compatibility constraint between model and duration ('incompatible combinations return HTTP 400') and the credit charging nuance based on produced duration. It also provides context for the request_id parameter by linking it to getVideoResults. 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 starts with a specific verb and resource: 'Generate a video from 1-5 reference images and a text prompt (references-to-video).' It also explicitly differentiates from siblings: 'Unlike createVideo, which animates a single source image, this composes a new scene that borrows characters, objects, and style from the reference images.' This clearly states what the tool does and distinguishes it from similar 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 provides explicit guidance on when to use this tool versus alternatives: 'Unlike createVideo...', and 'Related tools: createVideo for image-to-video, editVideo to modify a generated video.' It also mentions the synchronous behavior and credit model, helping the agent decide if this tool fits the task.

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

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

With no annotations provided, the description fully discloses behavioral traits: synchronous blocking with a single audio URL result, HTTP 400 on text exceeding 200 characters, credit charging on success, API key requirement, and request_id tagging for future retrieval. This goes well beyond basic expectations.

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 moderately long but well-structured, front-loading the purpose and then covering constraints, sync behavior, alternatives, auth, and credits. No sentence is wasted, and the length is justified by the tool's complexity.

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

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

Given the tool's complexity (nested requestBody, multiple optional fields, synchronous vs asynchronous concerns, credits, auth) and the absence of an output schema, the description is remarkably complete. It covers purpose, alternatives, error conditions, return format (single audio result with URL), auth scope, and credit cost.

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 a baseline of 3 is appropriate. The description adds minimal parameter-specific meaning beyond the schema—it repeats that voice_description and text are required and that type selects human/non-human, but does not elaborate on augment_prompt or other parameters beyond what the schema already states.

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 'Design a new voice from a character description...' which provides a specific verb and resource, clearly distinguishing it from siblings. It explicitly names createSpeech and createSpeechPreset as alternatives for different use cases.

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 states when to use this tool vs alternatives: 'Use this to invent and audition a voice from a description; use createSpeech for text-to-speech that clones a specific voice...' This is clear, actionable guidance with no 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?

With no annotations provided, the description takes on the full burden and succeeds: it discloses synchronous blocking behavior, credit charging on success, 15MB size limit with HTTP 400, image upload and validation, and authentication needs. It also clarifies the mutation aspect by explaining that edited variations are returned as results.

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 its primary purpose and then efficiently covers behavior, sibling distinctions, credits, and authentication. Each sentence provides unique value, and despite its length, it remains focused and well-structured without redundancy.

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

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

Given the complexity and absence of an output schema, the description thoroughly addresses return format (array of image results with url), one error condition (HTTP 400), behavior (synchronous), credits, authentication, and tool selection. It leaves no significant gaps for a tool of this scope.

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

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

Schema coverage is 100%, establishing a baseline of 3. The description adds meaningful operational context beyond the schema, such as the 15MB limit applying to the image parameter, credits scaling with n, and synchronous execution—details that enrich parameter understanding beyond the raw schema definitions.

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: 'Modify an existing image according to text instructions'. It explicitly differentiates from siblings by stating 'use editImage to transform a specific existing image; use createImage to generate from text alone, generateWithStyle to borrow a reference's art style, and removeBackground for the dedicated background-removal case', earning full marks.

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

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

Usage context is explicitly provided: the description names when to use this tool and clearly contrasts with four alternative tools. It also includes the API key requirement, giving a complete picture of when and how the tool should be invoked.

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

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

With no annotations, the description carries the full burden. It discloses synchronous blocking, the 7-day source expiration, API key and scope requirements, conditional prompt requirements per mode, and the exact crediting policy. This is thorough and goes well beyond the input 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 long but front-loaded with the core purpose and modes. Every sentence contributes operational detail, though the two separate credit sentences could be combined. Still, for a multi-mode tool with auth, sync, and output constraints, the length is justified.

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 and absence of an output schema, the description covers modes, source requirements, parameter interactions, return shape, synchronous behavior, auth, and pricing. It is self-sufficient for an agent to 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?

The schema already describes all parameters, so the baseline is 3. The description adds meaningful cross-parameter context: edit_mode-specific prompt rules, source URL provenance restrictions, reference image limits, and the request_id retrieval workflow. It does not describe every parameter, but the schema covers them.

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 immediately states a specific verb and resource: 'Edit a previously generated spritesheet', and enumerates the three edit modes (prompt, outpaint, fix_loop). This clearly differentiates it from sibling tools like animateSprite or editImage.

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 explicitly states when to use the tool (editing a previously generated spritesheet), when not to use it (arbitrary external images are not accepted), and where the source URL must come from (animateSprite, transferMotion, or a previous edit). It also clarifies synchronous execution and success-based crediting.

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?

In the absence of annotations, the description discloses key behavioral details: 'Synchronous: the call blocks until rendering finishes,' 'Credits are charged only on success,' and 'never more than the duration you requested.' It also notes the 7-day validity restriction and API key requirement, giving the agent a clear safety and cost profile.

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?

At roughly 150 words, it is dense but not bloated. Information is front-loaded with the core action first, followed by prerequisites, behavior, pricing, and related tools. Each sentence adds a distinct 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 synchronous video-edit tool with no output schema, the description covers input provenance, constraints, sync behavior, return value, cost model, auth, and sibling relationships. No critical behavioral aspect is unexplained.

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

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

The input schema already provides 100% descriptive coverage for parameters, so the baseline is 3. The description does add contextual value by reinforcing the source constraint for `video` (must be from specific sibling tools) and the purpose of `request_id`, but it largely complements rather than extends 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 clear verb+object: 'Edit a previously generated video with a text prompt and optional reference images.' It specifically distinguishes this from sibling creation tools by emphasizing 'previously generated' and referencing `createVideo` and `createVideoFromReferences`, making the purpose unambiguous.

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

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

It explicitly states when to use the tool: 'Pass the video url you received from createVideo, createVideoFromReferences, or an earlier edit.' It also provides alternatives via 'Related tools: createVideo to generate the source clip, createVideoFromReferences for reference-driven generation' and an exclusion: 'arbitrary external videos are not accepted.'

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

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

With no annotations, the description fully discloses behaviors: synchronous blocking call, credit charging only on success scaled by n, the structure of the result array including suggested motion_prompt, and the auth requirement ('Requires an API key (user scope)'). It also states the tool preserves the character.

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 longer than a single sentence but every sentence contributes: purpose, input types, output structure, credit cost, usage flow, and alternatives. It is well-structured with the main purpose first, usage guidance in the middle, and credit info appended.

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, output, error-prone details (credits, sync behavior), limitations (sprite only), workflow context, and authentication. With no output schema, it explains exactly what the returned array contains, making it fully self-contained 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?

The schema already provides 100% parameter descriptions, but the tool description adds semantic context: explains how pose and description work together when 'Other' is chosen, clarifies n as variation count, and notes request_id can be used with getSpriteResults. This adds value beyond the schema.

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

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

The description opens with a clear, specific verb+resource: 'Re-pose an existing sprite into a new target pose while preserving the character.' It also distinguishes the tool from siblings by naming animateSprite and rotateSprite as alternatives with different uses.

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

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

Explicit guidance is provided: 'This is typically the first step before animating' and 'use rotateSprite instead when you want to change the camera angle rather than the pose.' It also states the input type limitation ('Only works with sprite image types') and mentions required API key scope.

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

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

No annotations are provided, so the description carries full burden. It discloses synchronous behavior, return format (array of results with urls), upload/validation of style_image, HTTP 400 rejection for >15MB, credits charged only on success, API key requirement (user scope), and per-result credit cost. This is exemplary behavioral 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 dense but every sentence provides value: purpose, inputs, behavior, alternatives, and optional parameter. It is front-loaded with the core purpose and then logically flows into constraints and sibling comparisons. Slightly long, but each clause earns its place; no redundancy.

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

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

Despite having no output schema, the description explains the return structure (array of image results with url). It also covers prerequisites (API key), limits (15MB rejection), cost model, and alternative tools. For a tool with a nested request body and no annotations, this is comprehensive and 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%, so baseline is 3. The description adds semantic context beyond the schema by explaining that style_image can be URL or base64, image_type defaults to sprite, n controls number of variations, and request_id allows later retrieval via getImageResults. These enrich parameter understanding without repeating schema details.

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

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

The description opens with a specific verb ('Generate') and resource ('new images that match the visual style of a reference image'), clearly distinguishing this from siblings like createImage, editImage, and removeBackground. It also specifies the key inputs (style_image, prompt, image_type) and default behavior (defaults to sprite).

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

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

Provides explicit when-to-use guidance: 'Use this instead of createImage when style consistency with an existing asset matters; use editImage to alter the content of a specific image rather than borrow its style, and removeBackground to isolate a subject.' Also notes the synchronous blocking behavior and credit cost, which helps the agent decide when to invoke.

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

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

With no annotations provided, the description carries the full burden and does well: it explicitly states 'free read-only history lookup', 'no credits, no generation', 'it does not create anything', and 'Requires an API key (user scope)'. This discloses side effects, cost, mutation, and auth. It lacks pagination/limit details, but for a simple list tool the core behavioral traits are 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, all information-dense with no filler. The first sentence states the core purpose; the second clarifies safety and cost; the third explains the optional parameter and auth requirement. Front-loaded with 'List' and ends with essential invocation details.

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 list tool with no output schema, the description covers purpose, usage, safety, cost, auth, ordering, and parameter semantics. It is complete enough for an agent to select and invoke correctly despite the absence of structured annotations or output schema.

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

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

The schema only says 'Filter results by request_id'. The description adds meaningful context by explaining that the request_id corresponds to the original call to create3DModel and that filtering returns 'only the results tagged with that id'. This clarifies the parameter's provenance and usage beyond the schema, adding value despite 100% schema coverage.

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

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

The description opens with a clear, specific verb ('List') and resource ('3D models you previously generated through the API'), and includes ordering ('most recent first'). It explicitly distinguishes itself from creation tools by stating 'it does not create anything', and the sibling context shows it is the 3D-specific result-listing counterpart to tools like getImageResults.

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: it is a free, read-only history lookup, so an agent knows to use it when retrieving past 3D model generations rather than creating new ones. It references create3DModel as the source of request_id, implicitly guiding the agent to pair this tool with generation. However, it does not explicitly exclude alternatives like getImageResults, though the resource type makes that clear.

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

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

With no annotations provided, the description fully carries the burden. It explicitly discloses that the tool is free (no credits), read-only, and has no generation side effects. It also adds behavioral context like 'most recent first' ordering and the API key/user scope requirement, which go well beyond what structured data would 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?

The description is compact and front-loaded with the core purpose. Every sentence contributes new, non-redundant information: what it lists, ordering, cost, read-only nature, optional filtering, origin of the filter id, and authentication. 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?

The description covers the essential invocation details: purpose, ordering, filtering behavior, authentication, and relationship to creation endpoints. It does not mention pagination or the exact response structure, but given the simple single-parameter interface and lack of an output schema, the provided information is highly functional. A 5 would require at least a hint about the return format or pagination.

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's parameter description is generic ('Filter results by request_id'), but the tool description enriches it significantly by explaining that the id is the one passed when originally calling one of seven named create endpoints. This adds practical meaning about where the value comes from and how it behaves, exceeding the schema-only 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 opens with 'List audio clips you previously generated through the API, most recent first,' which clearly identifies the action (list) and resource (audio clips). It distinguishes this from sibling getters (e.g., getImageResults) by the media type and explicitly states it is a read-only history lookup.

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

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

The description explains when to use the tool (retrieve previously generated audio) and clarifies it is not for creating new content ('does not create anything'). It also names the seven create tools that produce the request_id, effectively showing which APIs generate the artifacts being listed. However, it does not explicitly contrast with other getter tools, so it stops short of a 5.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the operation is free, read-only, has no side effects ('does not create anything'), returns results most recent first, and requires an API key with user scope. It also explains the request_id filtering behavior and which upstream operations tag results with that ID. This is comprehensive for a read-only list tool.

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

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

The description is three sentences, each serving a distinct purpose: (1) core action and ordering, (2) read-only/no-credit clarification, (3) optional parameter behavior and authentication. There is no repetition or filler; the most important 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?

Given the tool's simplicity (one optional param, no required params, no output schema), the description covers all essential aspects: what it lists, ordering, side-effect-free nature, authentication, parameter semantics, and the relationship to generation endpoints. No significant gaps remain.

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

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

The input schema only says 'Filter results by request_id'. The description significantly expands this: 'Pass an optional request_id query parameter to return only the results tagged with that id when you originally called createImage, editImage, generateWithStyle, generatePose, rotateSprite, or removeBackground.' This adds critical context about the parameter's origin and usage, going well beyond the schema description.

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

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

The description clearly states the tool's action: 'List images you previously generated through the API, most recent first.' It explicitly identifies the resource (images previously generated) and the ordering, making it distinct from sibling tools like get3DModelResults or getVideoResults.

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

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

The description provides explicit usage context: 'free read-only history lookup (no credits, no generation); it does not create anything.' This clearly tells the agent when to use this tool (to inspect past results) and when not to use it (to avoid generation). It also mentions the request_id filter in relation to the generation tools that create those IDs, giving a concrete usage 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?

With no annotations provided, the description carries the full burden and excels by clearly stating this is read-only, creates nothing, and requires an API key with user scope. It also discloses ordering. While it doesn't mention pagination or error behavior, it covers the key behavioral traits.

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

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

Three sentences, front-loaded with the tool's purpose, then safety/usage, then parameter detail. 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?

For a simple list-retrieval tool with one optional param and no output schema, the description covers purpose, usage, safety, auth, and ordering. It does not detail return payload structure, but 'list spritesheets' conveys the expected result. Could mention pagination but not critical.

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 request_id as 'Filter results by request_id', but the description adds meaningful context by explaining the id originates from animateSprite or transferMotion calls, clarifying the filter's purpose.

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

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

The description uses a specific verb 'List' with resource 'spritesheets' and scope 'previously generated through the API, most recent first'. This clearly distinguishes it from sibling get*Results tools by focusing on spritesheets and referencing animateSprite/transferMotion.

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 explicitly states this is a free read-only history lookup with no credits or generation, implying it should be used for retrieving past spritesheet results rather than creating new ones. It also provides guidance on optional request_id filtering. It doesn't explicitly name alternative tools, but the context is clear.

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

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

No annotations are provided, so the description carries the full burden. It explicitly states the tool is read-only, creates nothing, requires an API key, and lists results most recent first, which are key behavioral traits. However, it does not detail response format or edge cases, which would have made it even more transparent.

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

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

The description is three sentences, front-loaded with the primary purpose, followed by cost/safety, parameter clarification, and auth. No wasted words.

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

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

For a simple read-only history tool with one optional parameter and no output schema, the description covers purpose, behavior, auth, and parameter semantics, making it sufficiently complete for an agent to use correctly.

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

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

The schema already describes the request_id parameter, but the description adds semantic meaning by explaining that the id is tagged when createVideo was originally called, helping the agent understand where to find the id.

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

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

The description clearly states the tool lists previously generated videos, with specific ordering ('most recent first'), and distinguishes it from sibling tools by specifying 'videos' and 'previously generated'. This makes the purpose unambiguous.

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

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

It provides clear context for when to use this tool: for read-only history lookup of previously generated videos, free of charge and without generating anything. It implies using createVideo for generation, though it does not explicitly name the alternative.

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

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

No annotations exist, so the description fully carries the transparency burden. It discloses the HTTP method (synchronous GET), absence of request body, exact return structure (animations, perspectives, directions arrays), that it is free (no credit charge), and the required API key scope.

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 detailed yet efficiently structured, front-loaded with the core purpose and then progressively adding return details, free-tier status, and sibling relationships. Every sentence provides new, actionable information without redundancy.

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

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

Given the tool has no parameters and no output schema, the description fully compensates by specifying the exact fields returned and how to use the output. It also covers authentication and cost, making it complete for an agent to decide when and how to invoke it.

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 reinforces that there is no request body, which adds a small semantic note beyond the empty 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?

Describes exactly what the tool does: lists animation presets, perspectives, and compass directions. It names the specific data fields returned and explicitly differentiates from sibling tools like transferMotion, animateSprite, and animate3DModelPreset.

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 when to use the tool: to obtain preset_id, perspective, and direction values for transferMotion, and to discover preset names for animation. It also pairs the tool with related siblings, giving 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?

With no annotations, the description fully discloses behavioral traits: synchronous call, single image result with a url, upload validation, 15MB limit with HTTP 400, credits charged only on success, API key requirement, and creative_edit pixel differences. This is exemplary 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 well-structured and front-loaded with the core purpose. It proceeds through input options, synchronization, validation, credits, alternatives, and request_id, with each sentence adding specific value and no wasted words.

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

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

No output schema exists, so the description explains the return format (single image result with url). It thoroughly covers auth, error conditions, credit charges, sync/async behavior, alternatives, and optional parameters, making it fully complete for a complex tool.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds slight context (e.g., request_id retrieval via getImageResults, creative_edit behavior) but largely restates what the schema already provides. No major additional meaning beyond the schema.

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

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

The description uses a specific verb and resource: 'Remove the background from a single image, returning the subject isolated on a transparent background.' It also explicitly distinguishes the tool from siblings like editImage, createImage, and generateWithStyle, making its purpose unmistakable.

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

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

Provides explicit when-to-use guidance: 'Use removeBackground for this dedicated cutout task; editImage can also remove backgrounds via a prompt but is better for broader edits, while createImage and generateWithStyle produce new images rather than process an existing one.' Also covers prerequisites like API key and synchronous behavior.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly discloses that the call is synchronous, blocks, returns a downloadable model_url, charges credits only on success, is non-destructive to geometry but replaces any prior skeleton (breaking old animations), and requires an API key with user scope. This is exemplary transparency.

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

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

The description is long but every sentence adds essential information: purpose, input format, synchronous behavior, rig_type options, joint_naming conventions, credit policy, side effects, and auth requirements. It is well-structured, starting with the core purpose and then systematically detailing parameters and behaviors. No wasted words.

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

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

Given the tool's complexity (5 rig types, 7 joint naming conventions, nested request object, no output schema), the description provides all necessary context: input, output, synchronous behavior, side effects on prior skeleton, credit charging, and auth. It also explains the differences between rig types and naming conventions in ways the schema does not, making it 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?

Although the top-level parameter has no schema description (0% coverage), the nested schema actually provides detailed descriptions for model, rig_type, and joint_naming. The description adds extra value by explaining the practical implications of rig_type options (e.g., 'humanoid_template (standard 22-joint skeleton with named joints, required for animating from the preset library)') and clarifying that joint_naming is purely a relabel without changing the skeleton. It does not mention request_id, but that parameter is optional and already 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 opens with a specific verb+resource: 'Rig a 3D model: generate a skeleton and skin weights for an existing GLB so it can be animated.' This clearly distinguishes it from sibling tools like create3DModel (creation) and animate3DModel (animation). It also specifies the input type (existing GLB) and outcome (animatable rig).

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 states the tool is for rigging existing GLB models to enable animation, and specifically notes that the humanoid_template rig_type is 'required for animating from the preset library'. It does not provide explicit exclusions or name alternative tools, but the context is strong enough for an agent to infer when to use it.

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

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

With no annotations provided, the description fully carries the burden. It discloses synchronous blocking behavior, output structure (array with url and applied angles), credit charging conditions (only on success, scaled by n), API key requirement, and per-result credit cost. This is comprehensive.

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

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

The description is long but every sentence adds value: purpose, limitations, alternatives, behavior, output, credits, auth, and parameter nuances. It is well-structured with a clear main description followed by a credit note. No fluff 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 no output schema, the description fully explains return values and behavior. It covers the nested requestBody structure via the schema and adds necessary context: synchronous result shape, credit costs, parameter defaults, and relationship to result retrieval (request_id). Complete for a complex tool.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaningful context beyond the schema: explains the semantics of camera_rotation angles (0=front, 45=front-right, etc.), elevation as 'keep current' when omitted, and n as number of variations. This enriches parameter understanding.

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

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

The description clearly states the tool re-renders an existing sprite from a different camera viewpoint while preserving character and pose. It explicitly distinguishes itself from sibling tools like generatePose, animateSprite, and transferMotion.

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: 'Use this to produce alternate view angles of a character' and explicitly names alternatives with counter-indications (use generatePose for pose changes, animateSprite/transferMotion for animation). Also states type restriction (sprites only, not icons or screenshots).

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

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

With no annotations provided, the description carries full behavioral disclosure. It states synchronous operation (blocks and returns directly, no polling), possible HTTP 400 errors, credit charging only on success, potential shorter actual duration than requested, API key requirement, and return contents (spritesheet URL plus optional GIF, individual frames, with-background). This goes well beyond basic annotation-like coverage.

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 front-loaded with the core purpose and each subsequent sentence adds essential information: input requirements, synchronous behavior, error conditions, credits, usage alternatives, auth, and price model. It is dense but not wasteful; slightly more organization could improve scannability, but it earns its length.

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

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

Given a complex nested schema, no output schema, and no annotations, the description covers all necessary context: what it does, required vs optional inputs, synchronous behavior, return values (spritesheet URL plus optional derivatives), error handling, credit costs, auth requirements, and how to obtain preset values. It is remarkably complete for a tool of this complexity.

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

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

Schema description coverage is 100%, so the schema already documents all parameters in detail. The description adds modest context about the conditional requirement (video or preset+perspective+direction) and the purpose of request_id for later retrieval, but this is light additional value. The baseline of 3 is appropriate since the schema carries 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 opens with a specific verb and resource: 'Transfer motion from a reference video or a named animation preset onto a static sprite image, producing an animated spritesheet.' This clearly distinguishes it from sibling tools like animateSprite (text-prompt generation) and listAnimationPresets (preset discovery), making the tool's function immediately clear.

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

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

Explicit usage guidance is provided: 'Use this when you have an existing motion clip or preset to copy; prefer animateSprite to generate animation purely from a text prompt, and call listAnimationPresets first to get valid preset_id, perspective, and direction values.' It also specifies the required input structure (image plus video or preset triple) and synchronous behavior, giving clear when-to-use and alternatives.

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

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

With no annotations, the description fully discloses behavior: synchronous blocking until finished, returns new URL and duration, billing per second and only on success, and rejection of larger sources. Also includes API key requirement and credits cost, giving complete behavioral transparency.

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

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

The description is dense but every sentence adds value: purpose, constraints, behavior, billing, optional identifier, related tools, and auth. It is front-loaded with the core action and logically organized.

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

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

Given no output schema and no annotations, the description covers all essential aspects: input requirements, synchronous behavior, return value, pricing, and related tools. It fully equips an agent to invoke the tool correctly without missing information.

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

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

Schema covers 100% of parameters but the description adds practical meaning beyond basic schema descriptions: details the video provenance and constraints, and clarifies how request_id can be used with getVideoResults. This enriches but does not dramatically surpass the schema.

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

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

The description clearly states the action: 'Upscale a previously generated video to twice its resolution (2x)' with a specific verb and resource. It distinguishes from sibling tools by explicitly limiting to previously generated videos and referencing related tools like createVideo and editVideo.

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 context: must be a video from createVideo, createVideoFromReferences, or editVideo, within 7 days, and under 960x960 pixels. It also names related tools and their purposes, giving clear alternatives and constraints for when to use this tool.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does disclose the success/error status codes, which is useful, but it fails to explain how the API key is supplied (since the schema has zero params) or mention any potential side effects. The 200/403 detail is valuable but the input mechanism remains opaque.

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 one efficient sentence that conveys the core purpose and expected responses with zero waste. It is ideally concise and front-loaded.

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

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

For a simple tool with no schema, annotations, or output schema, the description covers the essential purpose and responses. The only gap is the lack of explanation on how the API key is provided, but given the zero-parameter design, this is likely handled externally, making the description largely complete.

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

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

There are zero parameters, so the baseline is 4. The description identifies the subject (API key) but does not clarify how the key is transmitted, given the empty schema. However, since no parameters are expected, the description does not need to detail parameter values; still, a note about implicit authentication context would improve 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 uses a specific verb 'validates' and the resource 'API key', clearly stating what the tool does. It also provides distinct status codes (200/403) that set it apart from sibling tools, which are all media-related.

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 implicitly indicates this is for checking API key validity, but it does not explicitly state when to use it or mention any alternatives. Given that all sibling tools are unrelated, some contextual guidance on when to invoke validation would be helpful.

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