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 a key behavioral limitation: 'This adapter can use a token but cannot sign x402 payments itself.' It also clarifies that the workflow optionally verifies and retries with unlockToken. Because the verb is 'Explain,' the read-only nature is reasonably implied, though an explicit statement of no side effects would strengthen it.

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. The first sentence identifies the tool and summarizes the workflow in a clear colon-led list; the second sentence delivers the critical limitation. There is no filler, repetition, or unnecessary detail.

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

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

For a simple explanatory tool with one optional parameter and no output schema, the description gives enough context to select and invoke it correctly: it explains the workflow, the retry behavior, and the adapter's signing limitation. It does not describe the return format, but the purpose makes it obvious that the tool returns an explanation. A short note on return structure would be the only meaningful addition.

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

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

The input schema already provides 100% coverage for the single parameter, including that baseUrl is optional, is a URI, and defaults to https://quokkapix.com. The description does not add any additional meaning about baseUrl, but it does not need to because the schema fully documents it. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Explain') and identifies a clear resource: the unified Image/PDF/Video x402 workflow. It enumerates the exact steps involved—inspect locally, quote exactly, pay the product endpoint, optionally verify, retry with unlockToken—so an agent understands precisely what this tool covers and that it is distinct from the processing and payment sibling 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 clear context for when this tool is relevant: when someone needs to understand the overall x402 payment flow across image, PDF, and video assets. It also notes the important limitation that the adapter can use a token but cannot sign payments, which helps an agent avoid using it as a payment execution tool. It does not explicitly name alternative tools or 'when not to use' conditions, but the role is clear enough.

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 of behavioral disclosure. It explicitly states the tool is non-transactional ('does not sign, submit or consume a payment') and describes the data as 'live', indicating a network fetch. It does not discuss authentication or failure behavior, but the most critical side-effect disclosure for a read-only tool is present.

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 efficiently structured: the first sentence states exactly what is fetched, and the second sentence clarifies a key behavioral boundary. There is no filler or repetition of schema details, and 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?

For a tool with one optional parameter, no output schema, and no annotations, the description does enough by enumerating the returned information (tiers, free limits, endpoints) and stating the non-transactional nature. It does not explain the return structure, but this is not essential for an agent deciding whether to 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?

The description does not discuss parameters, but the single parameter baseUrl is fully documented in the input schema, including its optional nature and default value. With 100% schema description coverage, the baseline of 3 applies; the description does not need to add further parameter details.

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

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

The description uses the specific verb 'Fetch' and identifies the exact resource: 'QuokkaPix Image and Video payment tiers, free limits and product-specific x402 endpoints'. It also adds an important boundary by stating the tool 'does not sign, submit or consume a payment', which differentiates it from payment-related actions even without naming sibling 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 clear context for when to use the tool: when an agent needs live payment tier data, free limits, or product-specific x402 endpoints. It also includes an exclusion by stating it does not sign, submit, or consume a payment. However, it does not explicitly name alternatives like explain_payment_flow or verify_unlock_token, so it falls short of full alternative-based guidance.

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

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

No annotations provided, so description carries full burden. Mentions it returns a recipe and does not process images, but does not disclose whether it is read-only, required permissions, or side effects. For a retrieval tool, minimal disclosure is acceptable but could be improved.

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

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

Two concise sentences. First sentence states purpose. Second sentence provides usage context and exclusion. No redundancy or filler.

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

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

Given no output schema, description adequately explains what the recipe contains (applySettings, max file limits, payment expectations, QA checks). Parameter examples and sibling differentiation complete the picture for a simple retrieval tool.

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

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

Schema coverage is 100% and description adds value by providing context for the 'id' parameter: 'Recipe id from list_recipes, for example shopify_product_pack, amazon_product_batch or metadata_clean_batch.' This clarifies the source and acceptable values beyond schema.

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

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

Clearly states verb 'Return' and resource 'one official QuokkaPix recipe by id'. Distinguishes from siblings by specifying usage context 'before process_images'.

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

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

Explicitly says when to use: 'Use this before process_images when the agent needs exact applySettings...'. Also clarifies what it does not do: 'This tool does not process images.', helping differentiation from sibling process_images.

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 takes full burden and clarifies that it does not process files or invent missing rules, which are important boundary conditions. However, it does not disclose authentication requirements, rate limits, or idempotency, leaving some aspects undisclosed.

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

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

Two sentences with no wasted words. The first sentence states the primary action, the second clarifies limitations. Front-loaded and efficient.

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

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

For a simple lookup with one parameter and no output schema, the description lists returned fields and clarifies scope. It could improve by stating the output structure (single object), but is largely complete given the tool's simplicity.

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

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

The schema covers 100% of parameters with description and examples. The tool description adds no additional meaning beyond repeating 'by id', so baseline 3 is appropriate.

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

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

The description clearly states the verb 'Return' and the resource 'sourced platform image rule profile by id', and distinguishes from siblings like list_rule_profiles (which lists all) and process_images (which processes files). The negative clauses further separate it from processing 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 implies usage by requiring an id from list_rule_profiles and notes what it does not do (process files, invent rules), but lacks explicit when-to-use or when-not-to-use guidance or alternative tool names beyond the implied 'list_rule_profiles'.

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 of behavioral disclosure. It indicates the return content but does not state whether the operation is read-only, what happens if the id is invalid, or any side effects. It also doesn't mention authentication or other operational constraints. This is minimal for a simple getter but still leaves ambiguity.

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

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

The description is a single, efficient sentence that leads with the verb and concisely lists the return contents. There is no wasted wording, and it is easily scannable.

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

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

For a simple getter with one parameter, the description gives a high-level view of what is returned (recipe, browser settings, QA), but there is no output schema and no mention of error handling, response structure, or what 'expected-result QA' entails. Given the absence of structured return info, the description is adequate but not fully complete for an agent to know exactly how to interpret the response.

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

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

Schema coverage is 100%, with the id parameter fully documented as 'Video recipe id from list_video_recipes.' The description adds no extra parameter meaning beyond what the schema provides, so a baseline of 3 is appropriate.

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

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

The description clearly states the verb 'Return' and the resource 'one official Video recipe', and adds that it includes browser settings and expected-result QA. It differentiates from sibling tools like list_video_recipes (which lists multiple) and validate_video_recipe (which validates) through the singular 'one' and the inclusion of browser settings/QA, though it doesn't explicitly mention the id parameter.

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

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

No guidance is given on when to use this tool versus alternatives such as list_video_recipes or get_recipe. The description only states what it returns, with no mention of context or exclusions. An agent would have to infer when to call this versus listing or validating.

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 behavioral disclosure burden and does state the returned content: requirements, recommendations, and source URL. However, it does not mention error behavior, behavior for unknown ids, or whether the source URL indicates remote fetching.

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

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

The description is a single, efficient sentence with no filler. It front-loads the core action and packs the distinguishing output details into a compact structure.

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

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

For a simple one-parameter get operation, the description is nearly complete: it explains what is returned and the schema supplies the required id. It is missing minor details like not-found or error behavior, but nothing essential for selecting and invoking the tool.

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

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

Schema description coverage is 100%, and the id parameter is already documented with provenance ('from list_video_rule_profiles'). The tool description adds little parameter meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description states a specific action ('Return one Video profile') and details the result contents: separate requirements, recommendations, and source URL. The singular 'one' clearly differentiates this from list_video_rule_profiles, and the 'Video' qualifier separates it from the generic get_rule_profile sibling.

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

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

The description gives no guidance on when to use this tool versus alternatives such as list_video_rule_profiles or get_rule_profile. The only routing hint appears in the schema's parameter description ('id from list_video_rule_profiles'), not in the tool description itself.

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 implies a read-only list operation but doesn't explicitly disclose behavioral traits like side effects, rate limits, or data sensitivity. For a list operation, this is minimally adequate.

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

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

Three sentences, each earning its place: first clarifies purpose, second gives usage guidance, third explains return value utility. No wasted words.

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

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

Despite no output schema, the description explains that the return value consists of ids and how they can be used with related tools. It also lists many example use cases, making the tool's domain clear and complete for a list operation.

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

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

The tool has zero parameters and schema coverage is 100%, so the description need not add param info. Baseline 4 is appropriate as the description adds no redundant parameter details.

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

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

The description clearly states the tool lists 'official QuokkaPix local/browser image workflow recipes' and enumerates specific use cases (Shopify, Amazon, etc.), making the purpose highly specific. It also distinguishes from sibling tools like get_recipe by noting the returned ids can be passed to it.

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 tells the agent to 'Use this first' when needing a supported workflow for a list of tasks. It also explains what the return value (ids) can be used for, guiding the agent to subsequent tools like get_recipe or process_images.

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

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

No annotations provided, so description carries full burden. It discloses the tool lists profiles and marks secondary sources, but does not mention authentication, rate limits, or output format. Adequate but not rich.

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

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

Three concise sentences: first defines purpose, second gives usage guidance, third adds detail about secondary sources. 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 list tool with no parameters and no output schema, description is sufficient. It tells when to use and what it lists. Minor gap: return format not specified, 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?

No parameters exist, so schema coverage is trivially 100%. Description adds no parameter info, but the baseline for 0 parameters is 4. No further detail needed.

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

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

Description clearly states the verb 'list' and resource 'sourced image requirement profiles', and distinguishes from sibling tools like 'get_rule_profile' (singular) and 'list_recipes' (different resource).

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: 'before marketplace QA when an agent needs facts for...' and lists 17 specific platforms. Also notes that secondary sources are marked.

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 of behavioral disclosure. It adds the 'official browser-local' qualifier, which indicates the source and scope of the recipes, and implies these are built-in rather than user-generated. However, it does not describe the return format, whether it returns full recipe details or just names, or any pagination behavior. For a simple listing tool, this is acceptable but not rich.

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

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

A single sentence that is front-loaded with the core action and resource ('List official browser-local video recipes') followed by a concise enumeration of categories. No wasted words; every element earns its place.

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

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

For a zero-parameter listing tool without an output schema, the description is reasonably complete: it specifies what is listed and the scope. The only minor gap is that it doesn't clarify whether the response is a simple list of names or includes metadata, but this is not critical for a list operation. Given the simplicity of the tool, the description is sufficient.

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

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

The tool has zero parameters, so the baseline is 4 per the rubric. The description correctly focuses on the output rather than parameters, and no additional parameter information is needed since there are none.

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 (list), the resource (official browser-local video recipes), and enumerates the specific recipe categories (cutting, crop/resize, conversion, compression, audio, transcription, subtitles). This is unambiguous and distinct from sibling tools like list_recipes (generic) and list_video_rule_profiles (rule profiles, not recipes).

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

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

The description provides no guidance on when to use this tool versus its siblings. It does not mention alternatives like list_recipes or get_video_recipe, nor any conditions that would make this tool the right choice. The agent is left to infer usage from the name and 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 provided, the description carries the burden of behavioral disclosure. It correctly implies a read-only listing operation but does not mention authentication requirements, output format, or what 'official-source' means. Since it's a simple list, the lack of detail is partially acceptable, but more context would be helpful.

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

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

The description is a single, front-loaded sentence with no wasted words. It states the verb, resource, and scope efficiently, making it easy to scan.

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

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

Given the tool has zero parameters and no output schema, the description is adequate for an agent to understand the tool's purpose and scope. It lacks details about the return value structure, but for a simple list operation this is not a critical omission.

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

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

There are zero parameters, so the baseline is 4. The description does not need to explain parameter semantics. No additional meaning is required beyond what the schema already provides (an empty object).

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 ('List') and the resource ('official-source profiles') with specific platforms (YouTube, TikTok Ads, Meta Reels). It distinguishes from siblings like list_rule_profiles by specifying 'official-source' and video workflows, though it doesn't explicitly contrast with them.

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

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

No guidance is provided on when to use this tool versus alternatives such as list_video_recipes or get_video_rule_profile. The description does not mention scenarios where another tool would be more appropriate or when this tool should be avoided.

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 behavioral disclosure burden. It does well by revealing that source files stay local, that the browser returns a quote after ZIP/PDF inspection before paid processing, and that the call must be retried with the quoted token. It does not detail output-side effects like writing to outputDir, but the schema partially covers that.

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

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

Three sentences with no filler. The primary action is front-loaded, and the critical unlockToken workflow is explained compactly without duplicating schema content.

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

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

For a complex, payment-gated tool with no output schema and no annotations, the description provides a workable mental model of the quote-then-retry interaction and the local-file constraint. It does not explain every parameter, but the rich schema already documents those details sufficiently.

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

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

The input schema has 100% coverage, so the baseline is 3. The description adds meaningful semantics by explaining the unlockToken quote workflow and the relationship between recipeId and custom recipe, which supplements rather than repeats 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 ('Process') and a clear resource ('local image files through the QuokkaPix browser app'), and it names the two recipe modes. It clearly separates image processing from video siblings, though it does not explicitly contrast with process_with_settings.

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

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

The description implies usage for local image workflows and provides useful operational guidance for the quote-then-retry flow, but it does not explicitly state when to choose this tool over process_with_settings or other alternatives. The usage context is implied by 'local image files' and the recipe-based flow rather than stated as a direct comparison.

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

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

With no annotations, the description carries the burden and does meaningfully disclose behavior: it uses local Chromium, keeps media local, avoids paid work until an unlockToken is provided, and returns a duration/transcription quote first. It does not describe the post-token success behavior, but outputDir's schema description already indicates where results are written.

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

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

Two sentences with no filler. The first sentence front-loads the core local-processing behavior, and the second sentence gives the token/quote protocol. Every clause adds 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 9-parameter tool with a nested recipe object and no output schema, the description leaves the post-token output path implicit and does not explain recipe selection or how this differs from process_video_with_settings. The schema compensates for parameter details, and the two-step quote/token flow is enough to make a correct first call, but notable 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 schema already documents most parameters, and the description adds genuinely useful unlockToken semantics: omitting it triggers a quote, including it authorizes paid processing. That is beyond the schema's plain type/minLength information. It does not enrich headless or timeoutMs, but those are minor given the schema's type/range constraints.

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

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

The description names the concrete action: open a local video in local Chromium and keep media local. It is clearly about video processing with QuokkaPix, but it only weakly differentiates from the sibling process_video_with_settings and does not explicitly state the recipe-driven processing role.

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 actionable payment-flow guidance: omit unlockToken to receive a quote, then retry the same call with the product-specific token. However, it gives no when-to-use versus process_video_with_settings or process_images, and no exclusions or alternative routing.

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 must carry the behavioral burden, and it does disclose the main side effects: processing the video, saving media/transcript output, and writing quokkapix-video-result.json. However, it omits important behaviors like the unlock-token/quote flow, headless execution, potential overwrites, and failure modes, leaving a meaningful transparency gap.

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

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

The description is one compact sentence with no filler; every phrase earns its place by naming the input, the settings mechanism, the output artifact, and the result JSON. The primary action is front-loaded, making it easy to parse quickly.

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

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

For a 9-parameter tool with nested settings, no annotations, and no output schema, a single sentence is insufficient. It does not explain the unlock-token/quote alternative flow, the distinction between settings and settingsId, or runtime controls like headless and timeout. The schema descriptions cover some gaps but not enough to make the tool fully self-explanatory.

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 67%, which sets a baseline of 3. The description reinforces the key ideas of 'local video' and 'settings payload' but adds no new parameter-level meaning for headless, timeoutMs, settingsId, or the quote/unlock flow beyond what the schema already provides.

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

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

The description states a concrete action: run one local video through applySettings-compatible settings, save media/transcript output, and write quokkapix-video-result.json. It clearly names the resource, mechanism, and output artifacts, distinguishing it from recipe-based video processing and image-only siblings.

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

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

Usage is implied by 'direct QuokkaPix settings' and 'one local video,' but the description never names alternatives such as process_video or process_with_settings, nor does it state when not to use them. An agent has to infer selection criteria from the name and title rather than receiving explicit routing 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 disclose the core side-effect chain: 'The adapter downloads the output, writes quokkapix-result.json and returns QA results.' It also reveals the direct-payload execution mechanism. However, it does not surface the headless-Chromium/upload context or the payment-flow implications, which are left to parameter descriptions rather than the tool description.

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

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

Four sentences, each earning its place: purpose/mechanism, usage scope, multi-step guidance, and side-effect disclosure. The purpose is front-loaded before any alternatives or details, with zero filler.

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

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

This is a high-complexity tool (12 parameters, nested settings.steps and expectedResultQa objects, browser automation, x402 unlock-token flow) with no output schema and no annotations. The 100%-covered schema carries the parameter burden, and the description covers selection, mechanism, and output flow well. It is complete enough to select and invoke safely, though it defers browser/upload and payment context to the schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value beyond the schema by prescribing the preferred shape of the most complex parameter ('prefer settings.steps as [{ tool, settings }]') and enumerating typical tool ids, without repeating schema content.

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

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

Names a specific verb, resource, and mechanism: 'Process local image files with a direct window.QuokkaPixAgent.applySettings payload instead of an official recipe.' The 'instead of an official recipe' contrast clearly differentiates it from the recipe-based process_images sibling, and the workflow enumeration (resize/crop/convert/compress/background/watermark/effects/rename/PDF/favicon/scenario) further scopes what it handles.

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?

Gives explicit when-to-use guidance ('Use this for custom ... workflows') and a structural prescription ('For multi-step scenarios, prefer settings.steps as [{ tool, settings }]'). The 'instead of an official recipe' phrase implies the when-not condition, but it does not name the recipe-based sibling explicitly, so the exclusion is implied rather than fully stated.

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

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

No annotations are provided, so the description must carry the full burden. It discloses that this is a non-destructive, safe operation ('preflight check only, does not open browser or process files'). However, it does not detail the validation error format, side effects, or exact behavior on invalid input. Given no annotations, a score of 3 is appropriate—adequate but not exhaustive.

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

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

Two sentences only, both front-loaded with key information. No redundant phrases. Every sentence adds value: the first states the purpose and the second provides usage context and differentiation.

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 (1 parameter, 100% schema coverage, no output schema), the description is complete enough. It explains the tool's role in the workflow (validate before process_images). It could be improved by hinting at the return value (e.g., success/failure), but that is not required since there is no output schema. Score 4 reflects minor gap.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds contextual value by listing key fields it validates (id, applySettings.mode/tool, steps, requires.maxFiles), but the schema already covers these. No additional syntax or format details beyond the schema. Score 3 per guidelines.

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 the specific verb 'Validate' and the resource 'custom QuokkaPix recipe'. It distinguishes from sibling tools like process_images by stating it is a preflight check that does not process files. It lists the exact fields validated (id, applySettings.mode/tool, steps, requires.maxFiles), making the purpose clear and distinct.

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

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

Explicitly states when to use: 'when an agent generated its own recipe JSON and needs to confirm...' and implies when not to use (e.g., for known-good recipes). It clarifies it is a preflight check only and does not open a browser or process files, which helps the agent decide when to call it vs. process_images.

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

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

No annotations provided, so the description carries the burden. It transparently lists what checks are performed (status, file counts, formats, etc.) and explicitly states what it does not do (read pixels or upload files), which is sufficient for a validation 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 two sentences, front-loaded with the purpose, and every sentence contributes meaning without redundancy.

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

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

For a validation tool with 4 parameters and no output schema, the description covers the key aspects: what it validates, when to use, and its limitations. It omits explanation of the optional ruleProfileId parameter, but overall it is adequate.

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

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

Schema coverage is 100%, baseline is 3. The description adds value by contextualizing parameters (e.g., 'official recipe or custom QA contract') beyond the schema, though it does not detail all parameters individually.

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

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

The description explicitly states the action (validate) and the resource (quokkapix-result.json manifest), and mentions it is used after specific sibling tools (process_images/process_with_settings), clearly distinguishing its role.

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 usage context: 'Use this after process_images/process_with_settings or when inspecting a previous run.' It also states what the tool does not do, setting expectations, but does not explicitly list when not to use it.

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

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

With no annotations provided, the description carries the full burden and does disclose two traits: no browser required and no media processed. However, it does not state whether the call is read-only, what validation actually checks, or what the result/error contract looks like on failure, which is a meaningful gap for a validation 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?

A single, front-loaded sentence with zero filler. The verb, resource, and both distinguishing constraints all appear before the period, and every word earns its place.

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

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

The tool has a nested-object parameter and no output schema, so the description must compensate. It conveys the core purpose and the key behavioral trait, but never explains what the validation result looks like or how this relates to the generic validate_recipe and validate_result_manifest siblings — functional but thin.

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

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

Schema coverage is 100% and the schema thoroughly documents the recipe object, including the settings.tool enum and the expectedResult sub-structure. The description adds no parameter-level meaning, so the high-coverage baseline of 3 applies.

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

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

The description names a specific verb ('Validate'), a specific resource ('custom Video recipe'), and adds two distinguishing constraints ('without opening a browser or processing media'), which separates it from media-processing tools. However, it does not explicitly differentiate it from the generic sibling validate_recipe, so it stops short of full clarity.

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 phrasing implies a non-destructive validation context — no browser and no media processing — which is a useful usage signal. But it never names alternatives (validate_recipe, validate_video_result_manifest, validate_result_manifest) nor states when validation should be preferred over processing, leaving the selection decision to inference.

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

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

With no annotations, the description must carry the full burden. It implies a read-only validation but does not explicitly state side effects, error behavior, permissions, or reversibility. The lack of any behavioral detail is a significant gap.

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

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

The description is a single concise sentence with no filler. It front-loads the primary purpose, though brevity comes at the cost of omitted 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?

The tool has nested objects and three parameters but no output schema. The description fails to explain what 'browser QA' means, how the recipe is used, the role of recipeId, or what constitutes a successful validation. It is far from sufficient for an agent to call this 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 67% (recipe and manifest have descriptions, recipeId does not). The description adds no new meaning beyond the schema; it does not explain how recipeId relates to the recipe object or how the 'browser QA' maps to the manifest fields.

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 (validate) and the target (quokkapix-video-result.json) against browser QA and an optional Video recipe. It distinguishes itself from generic validate_result_manifest by being video-specific, though 'browser QA' is ambiguous.

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

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

No guidance is provided on when to use this tool versus its siblings like validate_result_manifest or validate_video_recipe. The description does not mention alternatives, prerequisites, or exclusions.

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

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

With no annotations, the description carries the full behavioral burden, and it delivers the key safety property: the tool does not consume the unlock token, and consumption only happens when the paid batch actually starts. It also discloses that omitted fields trigger a live payment-options read, providing useful conditional behavior 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?

Two tightly written sentences. The first front-loads the action and safety guarantee, and the second adds important consumption semantics and default behavior. No filler or redundant restatement of the tool name.

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

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

For a 13-parameter tool with no annotations, no output schema, and many undocumented parameters, this description is not complete. It does not explain what the verification returns, how invalid tokens fail, which payment/processing sibling to pair it with, or how the remaining parameters affect the verification.

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 description adds meaning to scope, price, and currency by explaining their defaulting behavior via live payment options, which the schema does not mention. However, schema description coverage is only 54%, and several parameters such as surface, pdfPages, scenario, productId, transcribe, and durationSeconds remain undocumented in both schema and 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 states a specific action: safely preflight a QuokkaPix paid agent unlock token, and explicitly clarifies that the token is not consumed. This distinguishes it from any tool that would actually redeem or start a paid batch. The sibling list has no other token-verification tool, so the purpose is 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 clearly situates the tool as a preflight step before the paid batch starts, and explains that missing scope, price, or currency will cause it to read live payment options. It does not explicitly name alternatives or exclusions, but no sibling tool overlaps with this verification role.

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