Retro Diffusion Pixel Art

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds context about the key format and source, but does not explain side effects like session state changes or error handling.

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?

Single sentence, front-loaded with the purpose, no wasted words. Highly concise and clear.

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 single parameter with full schema, output schema exists, and annotations cover safety, the description is nearly complete. Minor gap: could clarify session effects.

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 already describes the api_key parameter in detail. The description adds no new meaning beyond the schema, 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 'authenticate' and the resource 'this MCP session with a RetroDiffusion public API key'. It is specific and distinguished from sibling tools like 'create_inference' or 'logout'.

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

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

No explicit guidance on when to use this tool versus alternatives. The description does not mention prerequisites, ordering (e.g., must be called before other tools), or when not to use it.

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

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

The description adds significant behavioral context beyond the annotations: it states that the endpoint is public, that responses exclude raw base64 payloads to keep outputs compact, and that the tool is not suitable for animations (delegating to other tools). Since annotations only provide readOnlyHint=false, openWorldHint=true, etc., the description fills in the gaps about what the tool does and does not return, and its side effects.

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-loads the main purpose, followed by usage tips and response format notes. It is not overly verbose, though some sentences could be tightened (e.g., 'For the highest quality prefer RD Pro styles...' and later 'Use input_image for...' are somewhat redundant). Still, it is concise enough for an agent to quickly grasp key information.

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

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

Given the tool's complexity (25 parameters, 4 required, with output schema present), the description covers essential contextual information: main use cases, parameter constraints, alternatives for animations, and response behavior. It is sufficient for an AI agent to understand when and how to invoke this tool appropriately.

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

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

The input schema has 100% description coverage for all 25 parameters, so the description does not need to add per-parameter details. However, the description provides general guidance on parameter usage (e.g., 'Use input_image for the main source image'), but not new semantics beyond the schema. Baseline score of 3 is appropriate.

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

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

The description clearly identifies the tool's purpose: generating images via the public /v1/inferences endpoint, with a focus on pixel art (as indicated by the title and style guidance). It distinguishes itself from sibling tools like start_inference_job for animations, and provides specific scope by mentioning preferred style classes and parameter usage.

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

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

The description offers explicit usage guidance: it recommends RD Pro styles for highest quality and using start_inference_job + get_inference_job for animations. It also clarifies when to use certain parameters (e.g., reference_images only on create_user_style/update_user_style), helping the agent select the right tool and parameters for 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?

Disclosures beyond annotations: explains that style_reference_images and style_reference_caption are baked into the custom style (persistent) and are not the same as per_inference reference_images. This clarifies the behavioral trait of style creation versus inference. Annotations were minimal (readOnlyHint, destructiveHint), so the description adds meaningful 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?

Two short, front-loaded sentences. First sentence states the primary purpose and endpoint. Second sentence adds critical clarification about parameter semantics. No filler. Every word earns its place.

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

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

Given 16 parameters, the description only highlights two. While the schema covers all parameters, the description could mention the required name parameter or common optional ones like description. The output schema exists, so return values are covered, but overall completeness is adequate but not rich.

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

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

With 100% schema coverage, baseline is 3. The description adds value by clarifying the semantic distinction between style_reference_images (baked in) and per_inference reference_images (not baked in), and by directing the agent to prefer style_reference_images over the alias reference_images. This reduces ambiguity.

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

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

Clearly states the tool creates a user style from the RD Pro template using the /v1/styles endpoint. The verb 'create' and resource 'user style' are specific, distinguishing it from sibling tools like update_user_style and delete_user_style.

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 some context about when to use the tool (creating a style from a template) but does not explicitly guide on when not to use it or contrast with alternatives like update_user_style. The distinction between style_level and per_inference references is helpful but more parameter guidance than usage context.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, covering destructiveness and non-read-only nature. The description adds that style_id can be internal or public id, which is useful but not deep behavioral context. No mention of error handling or side effects beyond the annotation indications.

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-loads the action, and is free of redundant content. Every sentence provides information: the endpoint and the acceptable id formats.

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 delete tool with two parameters and an output schema, the description is minimally adequate. It lacks usage guidelines, irreversibility warning (though destructiveHint implies it), and details about the output. With richer annotations, it is passable but not fully complete.

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

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

Schema description coverage is 100%, with detailed descriptions for both parameters. The tool description repeats part of style_id's description (internal or public id) but adds no new semantic information beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description clearly states the tool deletes a user style using the /v1/styles/{style_id} endpoint, specifying the verb and resource. It distinguishes from siblings like create_user_style and update_user_style by focusing on deletion.

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 deleting a custom style but provides no explicit guidance on when to use it versus alternatives, nor prerequisites or consequences. The action is straightforward, so implied usage is acceptable but not exemplary.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description adds value by stating 'Always free' and 'without running it', reinforcing safety and cost-free behavior. No contradictions. It doesn't detail what the cost/duration estimate looks like, but it's sufficient.

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

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

Two sentences, zero waste. Every word serves a purpose: validates, estimates, cost, duration, without running, always free. Ideal for quick scanning.

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 and the presence of an output schema, the description completely covers what the tool does: validate and estimate cost/duration without executing. No 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 description coverage is 100%, so the schema already provides individual parameter descriptions. The description adds no extra parameter-level meaning. Baseline 3 is appropriate.

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

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

The description clearly states it validates an edit-tool request and estimates cost/duration without running it. It uses a specific verb (validate/estimate) and resource (edit-tool request). It distinguishes itself from sibling tools like run_edit_tool (which executes) and estimate_inference_cost (inference vs edit).

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 pre-checking edit tool requests before execution, and 'Always free' encourages use. However, it lacks explicit when-not-to-use or alternatives. The context of siblings helps, but the description alone provides clear context.

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

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

Annotations already provide readOnlyHint=true and destructiveHint=false, so the description's addition of 'Estimate generation cost' aligns with these but does not add beyond. It is consistent, but the behavioral insights are already captured by annotations.

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

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

Three sentences, front-loaded with the main purpose. Every sentence adds value: first states the core function, second and third provide parameter guidance. 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 tool with 20 parameters and an output schema, the description gives a high-level purpose and some parameter usage hints. It does not explain the output structure (cost response), but the presence of an output schema compensates. Slightly more guidance on parameter combinations would improve completeness.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds marginal value by suggesting when to use certain parameters (e.g., input_image for main source), but also mentions 'style_reference_images' which is not in the schema, potentially causing confusion.

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: 'Estimate generation cost using the public /v1/inferences endpoint with check_cost=true.' It uses a specific verb('estimate') and resource('cost'), and distinguishes it from siblings like create_inference and estimate_edit_tool_cost.

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

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

The description gives clear usage hints for parameters like input_image and reference_images, but does not explicitly state when to use this tool versus alternatives (e.g., create_inference). It lacks 'when not to use' guidance, though the purpose implies cost-checking before generation.

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

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

Annotations already declare readOnlyHint, destructiveHint, and idempotentHint. The description adds that the endpoint is 'public', which is a behavioral trait not in annotations. However, it does not elaborate on other behaviors like rate limits or auth requirements.

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

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

The description is a single, concise sentence that directly states the purpose and endpoint. No unnecessary information.

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

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

Given the simple nature of the tool (one optional parameter, output schema exists), the description is adequate. It covers the core functionality and endpoint. Could be improved by mentioning that it is a simple get of balance.

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

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

The input schema has 100% description coverage for the one parameter. The description does not add any parameter-specific meaning beyond what the schema already provides.

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

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

The description clearly states the verb 'Get' and the resource 'credits/balance', and specifies the endpoint. It is clear what the tool does, but it does not explicitly distinguish from sibling tools like get_inference_job or get_service_status.

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

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

No guidance on when to use this tool versus alternatives or when not to use it. The description only states what it does, lacking usage context.

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

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

Annotations already provide readOnlyHint, idempotentHint, etc. The description adds that raw base64 payloads are excluded from output, which is useful behavioral info beyond annotations.

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

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

Two concise sentences with no waste. Important info 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?

With annotations, full schema, and output schema present, the description is complete enough for the tool's complexity.

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

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

Schema covers 100% of parameters with descriptions. The tool description does not add additional parameter-level detail, so baseline 3 is appropriate.

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

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

The description clearly states it checks the status of an async generation started with start_inference_job, lists possible statuses, and describes the result. This differentiates it from siblings like start_inference_job.

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 after starting a job via start_inference_job, but does not explicitly state when not to use or exclude alternatives. Still, the context is clear enough for an agent.

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

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

Annotations already provide readOnlyHint, idempotentHint, and destructiveHint=false. The description adds context by specifying the endpoint and that no authentication is needed, which aligns with annotations. No contradiction.

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

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

Two concise sentences with no wasted words. The first sentence states the purpose and endpoint, the second provides usage guidance. Front-loaded with essential information.

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

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

Given zero parameters, complete annotation coverage, and existence of an output schema, the description fully addresses the tool's purpose and usage context. It is complete for a health check 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 tool has no parameters, so the description correctly avoids parameter details. Baseline for zero params is 4. The description adds value by mentioning the endpoint path.

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

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

The description clearly states the tool checks RetroDiffusion subsystem health via specific endpoint /v1/status. It distinguishes from siblings by being a health check requiring no authentication, which is unique among the listed 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 explicitly says 'Useful before bulk generation runs', providing clear context for when to use this tool. It does not mention when not to use, but the guidance is sufficient for a simple health check.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, so description adds value by detailing what it explains (input_image, reference_images, style_reference_images). No contradictions.

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

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

Two sentences, front-loaded purpose, zero waste. Every sentence earns its place.

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

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

Complete for a read-only info tool with output schema. Explains usage context and parameter purpose 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?

Schema coverage is 100%, so description does not need to add parameter details. Baseline 3 is appropriate.

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

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

Description clearly states it explains how to use a public prompt_style, with specific verb 'explain' and resource 'prompt_style'. Distinguished from sibling tools like create_inference and list_available_styles.

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 advises use before create_inference when unsure about style parameters, providing clear context and alternatives.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false. The description adds 'unique public' qualifiers, which provide marginal behavioral context beyond annotations. However, there is no mention of potential side effects, authentication requirements, or pagination, which would elevate the score.

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?

Single sentence is focused and direct. Every word is necessary to convey the tool's purpose. 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?

For a simple read-only list tool with an output schema (not provided here) and rich annotations, the description adequately defines what is returned. It could be improved by noting that the list is of public models (already stated) and whether authentication is required (optional key implies optional auth).

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

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

With 100% schema description coverage, the schema fully documents the sole parameter (rd_api_key). The tool description does not add any parameter-specific meaning, so it meets the baseline expectation.

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

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

Description uses specific verb 'Return' and resource 'unique public model identifiers' with a clear endpoint reference '/v1/styles/selector'. It distinguishes the tool from sibling tools like list_available_styles and list_edit_tools by specifying 'models' and 'public'.

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

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

No explicit guidance on when to use this tool versus alternatives (e.g., list_available_styles). The description only states what the tool does without context of prerequisites, limitations, or typical use cases.

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

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

Annotations declare readOnlyHint, idempotentHint, and openWorldHint, so the safety profile is clear. The description adds the specific endpoint and mentions the metadata fields returned, providing useful behavioral context beyond annotations.

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

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

Two sentences, no fluff, front-loaded with purpose. Every word serves a purpose.

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

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

Given the tool has an output schema and 3 parameters with full schema coverage, the description adequately explains what the tool does and what can be discovered. It mentions key metadata fields, making it complete for a listing 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?

All three parameters have descriptions in the input schema (100% coverage). The description does not add additional meaning to the parameters; it only mentions the output metadata. Baseline 3 is appropriate.

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

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

The description clearly states the tool lists publicly available styles from a specific endpoint, and highlights that it provides valid prompt_style values and metadata like require_input_image and supports_reference_images. This is specific and distinguishes it from sibling tools like create_user_style.

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

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

The description explicitly says 'Use this to discover valid prompt_style values...', indicating when to use the tool. While it doesn't explicitly state when not to use or list alternatives, the sibling context implies differentiation, and for a listing tool this is sufficient.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds that the tool returns fields, costs, and limits, which is consistent and provides useful context beyond annotations.

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

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

The description is two sentences, no wasted words. First sentence states the action and endpoint, second adds context about what edit tools are for. Well front-loaded.

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

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

For a simple list tool with one optional parameter and an output schema, the description sufficiently covers the tool's purpose and what it returns (fields, costs, limits). Annotations cover safety, so no 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% for the single parameter (rd_api_key), and the description adds no additional parameter information. The schema already describes the parameter adequately, so baseline 3 is appropriate.

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

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

The description explicitly states the tool lists enabled canvas edit tools from a specific endpoint, with details on fields, costs, and limits. This clearly distinguishes it from sibling tools like run_edit_tool or estimate_edit_tool_cost.

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 that edit tools are the recommended way to post-process pixel art, implying use for discovery. However, it does not explicitly provide when-not-to-use or contrast with alternatives like estimate_edit_tool_cost.

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

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

Annotations already declare the operation as idempotent and non-destructive. The description adds the specific effect (clearing the API key) but does not elaborate on additional behavioral traits like session state or error scenarios.

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, direct sentence with no unnecessary words. It is front-loaded with the action and resource.

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

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

For a tool with no parameters, simple side effects (idempotent, non-destructive), and a clear purpose, the description is fully adequate to guide correct usage.

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, and schema coverage is 100%, so the description does not need to add parameter details. The baseline for zero-parameter tools is 4.

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

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

The description clearly states the action (clear) and resource (authenticated API key), making the purpose immediately obvious. It effectively distinguishes from the sibling 'authenticate' tool which handles login.

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 when logging out of a session. While no explicit when-not or alternatives are provided, the context of a single-function logout tool makes this sufficient.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false. The description adds context about cost (free vs. paid) and that the result is returned in base64. It does not elaborate on side effects or internal behavior, but with annotations present, the bar is lower; a score of 3 is appropriate.

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

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

The description is extremely concise: two sentences covering purpose, tool list, cost tiers, a usage recommendation, and output format. No redundant words. Front-loaded with the core action.

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

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

Given the tool has 26 parameters and an output schema, the description adequately covers high-level functionality, cost tiers, and output format. It does not detail every parameter, but schema handles that. The point to estimate_edit_tool_cost adds completeness. Slightly lacking is mention of synchronous vs. asynchronous behavior, but overall fine.

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%, meaning every parameter has its own description in the schema. The tool description does not add additional meaning beyond listing some tool names and mentioning cost. With complete schema documentation, the description adds marginal value, landing at baseline 3.

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

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

The description clearly states the tool runs a canvas edit tool on an image, lists available tools by cost tier, and mentions the endpoint. However, it does not explicitly differentiate from all sibling tools; but the sibling set includes many unrelated tools (e.g., authenticate, create_inference), so the purpose is clear enough.

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 advises using estimate_edit_tool_cost first for charged tools, and lists price tiers, guiding the agent on when to use this tool and what to consider beforehand. It does not explicitly state when not to use it, but the context is sufficient.

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

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

Discloses that the tool is async, returns a task_id, requires polling, and suggests a polling interval. Annotations already indicate non-destructive and non-read-only behavior, and the description adds valuable operational context beyond those hints.

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 comprises four concise sentences, each adding crucial information: action, usage, rationale, and follow-up. No extraneous content; efficient 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?

Given the tool's complexity (25 parameters, 4 required) and the presence of an output schema, the description sufficiently explains the async nature, use cases, and polling procedure. It does not cover every parameter, but that is handled by the schema, making the description complete enough for effective agent invocation.

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

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

The tool description does not elaborate on specific parameters; the input schema already provides 100% coverage with detailed descriptions. The description adds no additional parameter-level meaning, so baseline score of 3 is appropriate.

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

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

The description clearly states the tool starts an async inference job via POST, returns a task_id, and distinguishes it from synchronous alternatives by mentioning use cases that outlive a single MCP call, such as advanced animations and batches.

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 recommends using this tool for advanced animation styles and batches, and directs the agent to poll with get_inference_job every 2-5 seconds. This provides clear when-to-use and follow-up guidance.

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

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

Annotations already indicate the tool is non-destructive, idempotent, and not read-only. The description adds context about style-level references being baked into the custom style and not being per-inference references. It does not contradict annotations, but it provides limited additional behavioral detail beyond 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?

The description is concise with two sentences, but the second sentence could be integrated into the first for better flow. It is front-loaded with the action and endpoint, but lacks some structure. Overall, it's efficient and contains no unnecessary 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 18 parameters, a required style_id, and an output schema, the description is somewhat complete but could be more comprehensive. It highlights a key nuance (style-level vs per-inference references) but doesn't cover all aspects like the effect of reset_forced_dimensions or the default behavior of apply_prompt_fixer. The schema and output schema compensate partially.

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

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

With 100% schema description coverage, the baseline is 3. The description adds value by clarifying the difference between style_reference_images and reference_images, and noting that min_width/min_height must be provided together. However, for most parameters, the schema descriptions are sufficient.

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 purpose: updating a public RD Pro user style via a specific endpoint. The verb 'Update' and the resource 'public RD Pro user style' are explicit. While it doesn't explicitly contrast with sibling tools like create_user_style, the action is distinct enough.

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 guidance on when to use style_reference_images vs reference_images, but it lacks explicit when-to-use or when-not-to-use advice for the tool overall. No alternatives are mentioned, and there is no context about prerequisites or suitable scenarios.

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