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

With no annotations provided, the description carries full burden but lacks critical behavioral details. It mentions cancellation and optional deletion but doesn't disclose whether this requires specific permissions, if it's reversible, what happens to partial results, or error conditions (e.g., invalid prompt_id). For a mutation tool with zero annotation coverage, this 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, efficient sentence with zero waste. It's front-loaded with the core action ('cancel'/'interrupt') and includes the optional feature concisely. Every word earns its place without redundancy.

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

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

Given a mutation tool with 2 parameters, 0% schema coverage, no annotations, and no output schema, the description is incomplete. It lacks details on permissions, side effects, return values, error handling, and parameter specifics. While concise, it doesn't provide enough context for safe and effective use.

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 0%, so the description must compensate but adds minimal parameter context. It mentions 'specific generation' (hinting at prompt_id) and 'remove from queue' (hinting at delete_from_queue), but doesn't explain parameter meanings, formats, or interactions (e.g., if prompt_id is omitted, it cancels the current execution). With 2 undocumented parameters, this is inadequate.

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 with specific verbs ('cancel', 'interrupt') and resources ('a specific generation', 'the currently executing generation'), plus an optional action ('remove from queue'). It distinguishes itself from sibling tools like comfy_clear_queue (which clears the entire queue) and comfy_get_status (which only checks 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?

The description implies usage context by mentioning 'currently executing generation' and 'queue', suggesting it's for active or queued tasks. However, it doesn't explicitly state when to use this versus alternatives like comfy_clear_queue for bulk operations or comfy_delete_workflow for workflow management, nor does it specify 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 provided, the description carries the full burden. It discloses the confirmation requirement (a behavioral trait) and clarifies it doesn't affect running generations, but doesn't mention other important behaviors like whether this action is reversible, what happens to cleared items, or any permission requirements. The description adds some value but leaves significant behavioral gaps.

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 perfectly front-loaded with the core action in the first clause, followed by important clarifications. Every sentence earns its place - the first states what it does, the second clarifies scope, and the third specifies a requirement. Zero waste, maximum efficiency.

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 destructive queue-clearing tool with no annotations and no output schema, the description is adequate but incomplete. It covers the basic action and confirmation requirement, but doesn't address important context like whether this requires special permissions, what the response looks like, or error conditions. Given the tool's destructive nature, more behavioral disclosure would be beneficial.

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 only 1 parameter and 0% schema description coverage, the description compensates well by explaining the 'confirm' parameter's purpose ('Requires confirmation'). This adds crucial semantic meaning beyond the bare schema, though it doesn't specify the exact confirmation mechanism or format.

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

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

The description clearly states the specific action ('Clear all pending items from the queue') and distinguishes it from siblings by specifying it 'does not affect currently running generation'. This differentiates it from tools like comfy_cancel_generation which would affect active processes.

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 about when to use this tool (to clear pending queue items) and implicitly distinguishes it from cancellation tools. However, it doesn't explicitly mention alternatives like comfy_cancel_generation for stopping active processes or provide explicit 'when-not-to-use' guidance beyond the running generation clarification.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively communicates that this is a destructive operation ('Delete') and adds safety context ('Requires confirmation for safety'), which helps the agent understand the tool's impact and interaction requirements beyond basic functionality.

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

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

The description is extremely concise with two sentences that directly address purpose and a key behavioral trait. Every word earns its place, and the information is front-loaded without unnecessary elaboration, making it efficient and easy to parse.

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 (destructive operation with 2 parameters) and lack of annotations and output schema, the description is moderately complete. It covers the core action and a safety mechanism, but falls short in fully explaining parameter semantics, potential errors, or return values, leaving gaps for the agent to infer.

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 description coverage is 0%, meaning parameters are undocumented in the schema. The description mentions 'confirmation for safety' which loosely relates to the 'confirm' parameter, but provides no details about the 'name' parameter or the meaning, format, or constraints of either parameter. It adds minimal value beyond the bare schema.

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

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

The description clearly states the specific action ('Delete') and resource ('a saved workflow from the MCP library'), distinguishing it from sibling tools like comfy_list_workflows and comfy_save_workflow. It precisely communicates what the tool does without ambiguity.

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 deletion of saved workflows, but provides no explicit guidance on when to use this tool versus alternatives like comfy_clear_queue or comfy_cancel_generation. It mentions a confirmation requirement, which hints at safety considerations, but lacks context about prerequisites or specific scenarios for invocation.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While it mentions 'quick image generation' and 'pre-configured workflow templates,' it doesn't disclose critical behavioral traits like whether this is a synchronous or asynchronous operation, how long generation typically takes, what happens to queued jobs, error handling, or authentication requirements. For a complex image generation tool with 14 parameters, this leaves significant behavioral gaps.

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 appropriately concise with two sentences that efficiently convey the core value proposition. The first sentence establishes the main functionality with specific template examples, and the second sentence provides usage context. There's no wasted verbiage, though it could be slightly more structured with clearer separation of key concepts.

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 (14 parameters, image generation functionality), absence of annotations, and lack of output schema, the description is insufficiently complete. It doesn't explain what the tool returns (images, job IDs, status?), error conditions, performance characteristics, or how it integrates with sibling tools like comfy_get_output_images. For a generative AI tool with significant computational implications, more contextual information is needed.

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 0% schema description coverage for 14 parameters, the description provides minimal parameter guidance. It only mentions template names in the enum list but doesn't explain what each template does, when to choose which template, or how parameters like 'input_image' relate to 'basic_img2img' template. The description fails to compensate for the complete lack of schema descriptions, leaving most parameters semantically unclear.

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 as 'Quick image generation using pre-configured workflow templates' with specific template names listed. It distinguishes itself from sibling tools by emphasizing simplicity for 'common use cases without managing workflow JSON,' differentiating from more complex workflow management tools like comfy_submit_workflow. However, it doesn't explicitly contrast with all siblings like comfy_get_output_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?

The description provides implied usage guidance by stating it's 'ideal for common use cases without managing workflow JSON,' suggesting when to use this simplified tool versus more complex workflow management alternatives. However, it doesn't explicitly state when NOT to use it or name specific alternative tools for different scenarios, leaving some ambiguity about optimal 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds useful context about the return format ('full Windows paths that Claude Desktop can read'), which isn't obvious from the schema. However, it lacks details on permissions, rate limits, or error handling, leaving gaps for a tool that accesses file systems.

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

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

The description is front-loaded and efficiently structured in a single sentence, with zero wasted words. Every part ('List recent output images', 'from ComfyUI's output folder', 'Returns full Windows paths that Claude Desktop can read') adds essential information without redundancy.

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

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

Given the tool's moderate complexity (3 parameters, no output schema, no annotations), the description is partially complete. It clarifies the tool's purpose and return format but lacks details on parameter usage, error conditions, or integration with siblings, making it adequate but with clear gaps for effective agent use.

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 0%, so the description must compensate for undocumented parameters. It does not explain the meaning or usage of 'limit', 'sort', or 'filter' parameters, failing to add value beyond the schema. The baseline is 3 since the schema provides some structure (e.g., enums for 'sort'), but the description offers no parameter insights.

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 specific action ('List recent output images') and resource ('from ComfyUI's output folder'), distinguishing it from siblings like comfy_get_queue or comfy_get_status that handle different resources. It precisely defines what the tool does without being vague or tautological.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, exclusions, or compare it to sibling tools like comfy_list_workflows or comfy_upload_image, leaving the agent to infer usage context without explicit direction.

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

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

No annotations are provided, so the description carries full burden. It states it gets 'detailed information' but does not disclose behavioral traits such as rate limits, authentication needs, or what format the information is returned in. This is a significant gap for a tool with zero annotation coverage.

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

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

The description is a single, efficient sentence that front-loads the purpose ('Get detailed information about the current generation queue') and adds specific scope ('including running and pending items'). There is zero waste, making it highly concise and well-structured.

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

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

Given 0 parameters and no output schema, the description is adequate for a simple read operation but incomplete. It lacks details on return format, error handling, or behavioral context, which are important for an agent to use the tool effectively without annotations.

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 0 parameters with 100% schema description coverage, so no parameter information is needed in the description. The baseline for this scenario is 4, as the description appropriately focuses on purpose without 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 verb 'Get' and the resource 'detailed information about the current generation queue', specifying it includes 'running and pending items'. This distinguishes it from siblings like comfy_get_status (general status) or comfy_get_output_images (specific output).

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 checking queue details, but does not explicitly state when to use this tool versus alternatives like comfy_get_status or comfy_wait_for_completion. No exclusions or prerequisites are mentioned, leaving usage context somewhat vague.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adequately describes the core behavior (returns queue position, progress, and output paths) and hints at conditional output ('when available'). However, it lacks details on error conditions, rate limits, authentication needs, or whether this is a read-only operation (though 'Get' implies it). The description doesn't contradict annotations (none exist), but could be more comprehensive for a tool with potential side effects or constraints.

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

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

The description is two sentences that are front-loaded with the core purpose and efficiently detail the return values. Every word contributes essential information—no fluff or repetition. It's appropriately sized for a straightforward status-checking tool.

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

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

Given the tool's moderate complexity (2 parameters, no output schema, no annotations), the description is reasonably complete. It covers what the tool does, what it returns, and hints at parameter usage. However, it lacks explicit error handling or behavioral nuances (e.g., what happens if prompt_id is invalid), which would be needed for a perfect score. For a status tool without critical mutations, this is sufficient but not exhaustive.

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 2 parameters with 0% description coverage, so the description must compensate. It doesn't explicitly mention the parameters, but it clarifies the tool's dual purpose ('specific generation or the overall queue'), which implicitly explains the optional 'prompt_id' parameter. The mention of 'output paths' relates to the 'include_outputs' parameter. While not a direct parameter explanation, this adds meaningful context beyond the bare schema, justifying a score above baseline.

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

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

The description clearly states the specific action ('Get the current status and progress'), identifies the resource ('a specific generation or the overall queue'), and distinguishes it from siblings by focusing on status/progress retrieval rather than queue management (comfy_get_queue), cancellation (comfy_cancel_generation), or generation submission (comfy_generate_simple). The verb+resource+scope combination is precise.

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 context by mentioning 'a specific generation or the overall queue,' suggesting this tool can be used for both individual job tracking and queue overview. However, it doesn't explicitly state when to choose this over alternatives like comfy_get_queue (which might return different queue details) or comfy_wait_for_completion (which blocks until done). No explicit when-not-to-use guidance or prerequisite information is provided.

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

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

No annotations are provided, so the description carries the full burden. It mentions the tool lists resources and supports filtering, but does not disclose behavioral traits such as whether it's read-only, potential performance impacts, rate limits, or what the output format looks like (e.g., list structure, pagination). This leaves significant gaps for an agent to understand how to interact with it effectively.

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

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

The description is front-loaded with the core purpose in the first sentence and adds supporting details in the second, with zero wasted words. It efficiently communicates key information without redundancy, making it easy for an agent to parse quickly.

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

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

Given the complexity of listing multiple resource types with filtering, no annotations, and no output schema, the description is incomplete. It lacks details on return values (e.g., format, fields), error handling, or prerequisites, which are crucial for an agent to use the tool correctly in a ComfyUI context. The description does not fully compensate for the missing structured data.

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 0%, so the description must compensate. It adds meaning by explaining that parameters allow 'filtering by type and name,' which corresponds to the 'type' and 'filter' parameters, and implies resource listing. However, it does not detail the 'include_size' parameter or provide examples or constraints beyond what the schema's enum suggests. This partial compensation meets the baseline for low coverage.

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

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

The description clearly states the specific action ('List available models, checkpoints, LoRAs, VAEs, and other resources') and the location ('in the ComfyUI models directory'), distinguishing it from sibling tools like comfy_list_workflows which lists workflows rather than models. It uses precise terminology that matches the tool's name and scope.

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 mentioning 'Supports filtering by type and name,' suggesting when to use it for filtered queries, but does not explicitly state when to choose this tool over alternatives or provide exclusions. No sibling tools directly overlap, but guidance on when to use this versus other listing tools is lacking.

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 mentions filtering but doesn't describe return format, pagination, error handling, or whether this is a read-only operation. For a list tool with zero annotation coverage, this leaves significant gaps in understanding how the tool behaves.

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

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

The description is two sentences with zero waste: the first states the core purpose, and the second adds filtering details. It's front-loaded with the main action and appropriately sized for the tool's complexity.

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

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

Given no annotations and no output schema, the description is adequate for a simple list tool but incomplete. It covers purpose and parameters but lacks details on return values, error cases, or behavioral traits like whether it's safe or has side effects, which are important for an agent to use it correctly.

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

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

With 0% schema description coverage, the description compensates by explaining what the parameters do: 'filter' is for name, description, or tags, and 'tags' is an array for tag-based filtering. This adds meaningful context beyond the bare schema, though it doesn't detail exact syntax or 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 clearly states the verb 'List' and the resource 'all saved workflows in the MCP library', making the purpose specific and unambiguous. It distinguishes this tool from siblings like comfy_load_workflow or comfy_save_workflow by focusing on listing rather than loading or saving workflows.

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 through the mention of filtering capabilities, suggesting it's for retrieving workflows with optional filters. However, it doesn't explicitly state when to use this tool versus alternatives like comfy_list_models or comfy_get_queue, nor does it provide exclusions or prerequisites for usage.

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

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

No annotations are provided, so the description carries the full burden. It mentions that the tool 'Returns the workflow JSON and metadata,' which adds some behavioral context about the output. However, it lacks details on error handling, permissions, rate limits, or whether this is a read-only operation (implied but not stated). For a tool with zero annotation coverage, this is insufficient.

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 front-loads the core action and includes the return value. There is no wasted language, making it highly concise and well-structured for quick understanding.

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

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

Given the tool's moderate complexity (1 parameter, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose and output but lacks details on usage context, error cases, or behavioral nuances. Without annotations or an output schema, more completeness would be beneficial, but it meets the minimum viable threshold.

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 specifies that the tool loads 'by name,' which clarifies the purpose of the single parameter 'name' in the input schema. Since schema description coverage is 0%, the description compensates by adding meaningful context about what the parameter represents, though it doesn't detail format constraints or examples.

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 ('Load') and resource ('saved workflow from the MCP library by name'), with a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'comfy_list_workflows' or 'comfy_get_workflow' (if such existed), which would be needed for a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'comfy_list_workflows' (which might list workflows) and 'comfy_save_workflow' (which saves workflows), there's no indication of prerequisites, timing, or distinctions between these operations.

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

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

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It mentions metadata inclusion (description, tags) but omits critical details: whether saving requires authentication, if it's idempotent (hinted by 'overwrite' parameter but not explained), potential rate limits, error conditions (e.g., duplicate names), or what happens on success (e.g., confirmation message). For a write operation with zero annotation coverage, this is inadequate.

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 appropriately concise with two sentences that efficiently convey the core purpose and metadata aspects. It's front-loaded with the main action and avoids unnecessary details. However, the second sentence could be integrated more smoothly, and there's room to add brief usage context without bloating.

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

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

Given the complexity (a write operation with 5 parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't address behavioral aspects like permissions, idempotency, or error handling, and parameter coverage is partial. For a tool that saves data to a library, more context on success/failure outcomes and operational constraints is needed.

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 0%, so the description must compensate but only partially does. It mentions 'metadata like description and tags' which maps to two parameters (description, tags), but doesn't explain 'name' (required, with pattern), 'workflow' (required, JSON or object), or 'overwrite' (default false). Since it covers 2 of 5 parameters (40%), it adds some value but falls short of fully compensating for the schema gap.

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

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

The description clearly states the action ('Save a workflow JSON') and resource ('to the MCP library for later reuse'), which distinguishes it from sibling tools like comfy_delete_workflow or comfy_load_workflow. However, it doesn't explicitly differentiate from comfy_submit_workflow (which might execute workflows) or comfy_list_workflows (which lists them), leaving some ambiguity about exact sibling distinctions.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing workflow), exclusions (e.g., not for executing workflows), or direct comparisons to siblings like comfy_load_workflow (for retrieval) or comfy_delete_workflow (for removal), leaving usage context unclear.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions execution and parameter overrides but fails to cover critical aspects like whether this is a read-only or destructive operation, authentication needs, rate limits, or what happens upon submission (e.g., queueing, immediate execution). This leaves significant gaps for an agent to understand the tool's behavior.

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

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

The description is efficiently structured in two sentences, front-loading the core purpose and adding a clarifying detail about overrides. Every word contributes meaning without redundancy, making it appropriately concise.

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

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

Given the complexity (3 parameters with nested objects, no annotations, no output schema), the description is incomplete. It doesn't address execution outcomes, error handling, or the relationship between workflow and overrides, leaving the agent with insufficient context for reliable tool 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 schema description coverage is 0%, so the description must compensate for undocumented parameters. It mentions 'parameter overrides' and 'workflow JSON,' which loosely maps to the 'overrides' and 'workflow' parameters, but doesn't explain the 'client_id' parameter or provide details on override usage, format, or constraints. This adds minimal value beyond the schema.

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

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

The description clearly states the action ('submit') and resource ('complete workflow JSON to ComfyUI for execution'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'comfy_generate_simple' or 'comfy_load_workflow', which prevents a perfect score.

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 context by mentioning 'parameter overrides for dynamic modifications without editing the workflow structure,' suggesting this tool is for executing workflows with customizations. However, it lacks explicit guidance on when to use this versus alternatives like 'comfy_generate_simple' or prerequisites, leaving some ambiguity.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'overwrite control', which hints at mutation behavior, but does not detail permissions, side effects, error handling, or rate limits. This is inadequate for a tool that modifies system state, leaving significant gaps in understanding its operational traits.

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

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

The description is front-loaded and concise, consisting of two sentences that directly state the tool's function and key features without unnecessary elaboration. Every sentence adds value, making it efficient and well-structured for quick comprehension.

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

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

Given the complexity of an upload operation with no annotations, 0% schema coverage, and no output schema, the description is incomplete. It lacks details on return values, error conditions, and full parameter semantics, which are crucial for an agent to use the tool effectively in workflows.

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 some meaning by mentioning 'custom filenames and overwrite control', which relates to the 'filename' and 'overwrite' parameters. However, with 0% schema description coverage and three parameters, it does not fully compensate for the lack of schema details, such as explaining 'image_path' format or constraints, resulting in a baseline score.

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 ('Upload an image') and resource ('to ComfyUI's input folder for use in workflows'), making the purpose evident. However, it does not explicitly differentiate from sibling tools like 'comfy_get_output_images' or 'comfy_submit_workflow', which might involve images but serve different purposes, so it falls short of a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It mentions the tool's function but does not specify scenarios, prerequisites, or exclusions, such as when to prefer this over other image-handling tools in the sibling list, leaving the agent with minimal 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?

No annotations are provided, so the description carries the full burden. It discloses key behavioral traits: blocking behavior, handling of completion/failure outcomes, and return of image paths. However, it lacks details on error handling, rate limits, authentication needs, or what happens on timeout (though timeout is a parameter). For a tool with no annotations, this is a moderate disclosure but misses some operational context.

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

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

The description is highly concise and well-structured: two sentences that front-load the core functionality ('Block until...') and follow with a usage note ('Useful for...'). Every word earns its place with no redundancy or fluff, making it efficient 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 the tool's complexity (blocking wait with 3 parameters), no annotations, no output schema, and 0% schema coverage, the description is moderately complete. It covers the main purpose and usage context but lacks details on parameters, return values (beyond 'image paths'), error cases, or sibling tool comparisons. For a tool with these gaps, it provides a basic but incomplete picture.

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 0%, so the schema provides no parameter descriptions. The description adds no explicit parameter semantics—it doesn't explain prompt_id, timeout, or poll_interval. However, it implies the purpose of waiting for a generation, which relates to prompt_id. With 0% coverage and 3 parameters, the description compensates minimally, meeting the baseline for moderate schema coverage gaps.

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: 'Block until a generation completes or fails. Returns final outputs with image paths.' This specifies the verb (block/wait), resource (generation), and outcome (completion/failure with outputs). It distinguishes from siblings like comfy_get_status (check status without blocking) and comfy_get_output_images (retrieve images without waiting). However, it doesn't explicitly name these siblings for differentiation, keeping it at 4.

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 implied usage guidance: 'Useful for synchronous workflows.' This suggests when to use it (synchronous contexts) but doesn't explicitly state when not to use it or name alternatives like comfy_get_status for non-blocking checks. No prerequisites or exclusions are mentioned, leaving some gaps in guidance.

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