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

No annotations are provided, so the description carries the behavioral disclosure burden. It correctly discloses the core action and its two possible effect paths, but it does not mention edge cases like what happens if the job is already finished, whether cancellation is idempotent, or whether partial outputs are preserved.

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

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

A single, dense sentence that front-loads the action and scope, then explains the two possible behaviors. Every part is informative and there is no filler.

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

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

The tool is simple with one required parameter and an output schema available, so the description need not cover return values. It provides enough context for an agent to choose and invoke the tool correctly, though it omits minor details like failure modes and whether partial results remain accessible.

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 0% because job_id has no description. The description indirectly clarifies that job_id must identify 'this server's own jobs,' which adds some meaning beyond the raw schema, but it does not specify the expected format, where to obtain a valid job_id, or any constraints on the value.

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

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

The description uses a specific verb 'cancel' with a clear resource: 'one of this server's own jobs.' It explicitly states the two behavioral outcomes (removing from queue or interrupting if running), which fully differentiates it from siblings like job_status, wait_for_job, and fetch_result.

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

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

The description clearly establishes the context of use: canceling a job on this server. It implies a scope constraint ('this server's own jobs') but does not explicitly name alternatives or say when not to use this tool, such as checking job status first or waiting instead of canceling.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly explains how the first image sets the output canvas, is fitted and padded (never stretched), and that later images are supporting references at ~1 MP. It also notes that width/height can override the canvas and defers other behavior to generate_image. This gives valuable insight into image handling, though it does not cover error cases or rate limits.

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

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

The description is long but well-structured, using indented bullet points for model, images, and instruction. Each line adds value, and the most important usage detail (image order and instruction format) is front-loaded. Some redundancy exists (e.g., repeating the instruction example), but it is justified by complexity. It is not overly verbose for an 11-parameter 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 11 parameters, no annotations, and no output schema, the description needs to be comprehensive. It covers the essential parameters and signals that the return value matches generate_image. However, it does not explain the remaining parameters or the exact structure of the output, relying on a sibling tool for those details. An agent cannot fully understand the tool's behavior without consulting generate_image, which introduces a dependency.

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 0%, so the description must compensate. It thoroughly explains the three most critical parameters: model (available options), images (order, path/base64, role), and instruction (operation-first, explicit roles). However, it does not describe cfg, save, seed, count, steps, negative, width, or height individually, instead deflecting all of them to 'match generate_image.' This cross-reference is helpful only if that sibling's description is equally thorough, making the current tool incomplete on its own.

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

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

The description opens with a clear, specific statement: 'Edit one image, or compose a new image from 2-4 reference images.' This establishes the verb (edit/compose), resource (image), and a distinct capability that separates it from the sibling generate_image (text-to-image). The inclusion of concrete operation examples reinforces the purpose 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 provides explicit operational guidance on how to structure the instruction parameter, including role ordering for subject/scene composition. It implies when to use (when you have an existing image to edit or combine) and naturally distinguishes from generate_image by focusing on reference images. However, it does not explicitly name generate_image as the alternative for text-only generation or state when NOT to use this tool, so it falls short of a 5.

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

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

With no annotations, the description carries the burden. It discloses the failure behavior (fails if job not done) and the return content (preview + saved path). However, it doesn't disclose whether the save parameter affects the saved path, whether the operation is read-only, or any side effects like writing files to disk.

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 with the main purpose, and the failure condition is stated concisely. No wasted words.

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

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

For a simple 2-param tool with no output schema, the description covers the core behavior and failure mode. However, the save parameter's effect is unexplained, and there's no mention of the return format or how the saved path is provided. Given the sibling tools, an agent might benefit from knowing this is the retrieval step after wait_for_job.

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 explains job_id implicitly (identifies the job) and save is mentioned only as 'saved path' in the return, but the description doesn't clarify what the save boolean does. The description adds some meaning but leaves the key parameter save ambiguous.

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

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

The description clearly states the tool returns images of a finished job, including preview and saved path, and explicitly notes it fails if the job is not done. This distinguishes it from siblings like job_status (which likely just reports status) and wait_for_job (which waits), though it doesn't name them explicitly.

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 when to use it: after a job is finished, and warns it fails if not done. This implicitly guides the agent to use wait_for_job or job_status first. However, it doesn't explicitly name alternatives or state when not to use it beyond the failure condition.

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

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

With no annotations provided, the description carries the full burden and succeeds. It discloses blocking behavior and typical timing, the difference between writing files and returning base64, that the seed is always returned for reproducibility, and what to do if a job_id appears. This is rich operational behavior that an agent could not infer from the schema.

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

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

The description is longer than average, but it is densely informative and organized by parameter area. Each line adds a necessary constraint, default, or behavioral fact, and the core purpose is front-loaded. Nothing reads as filler.

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

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

For a high-complexity tool with 11 parameters, no annotations, and no output schema, this description is complete. It covers input choices, defaults, output modes, timing, reproducibility, and async fallback behavior. An agent has what it needs to call the tool correctly and interpret the result.

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 0% description coverage, so the description is the only source of parameter meaning. It explains every parameter: model, canvas/aspect, seed, steps, cfg, count, save, prompt, and negative, including defaults and constraints such as multiples of 32 and count 1-4. This fully compensates 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 opens with 'Generate new image(s) from a text prompt,' a specific verb and resource. The word 'new' distinguishes it from the edit_image sibling, and the rest of the description stays focused on generation rather than manipulation.

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 concrete routing guidance: use list_models to see installed models, and if the server returns a job_id, use wait_for_job(job_id). It also explains when save=false is useful and notes that negative prompts only matter when cfg > 1, which is practical selection 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 present, so the description carries the behavioral burden. It conveys read-only character via 'peek' and non-blocking behavior via 'without waiting.' However, it does not disclose error behavior, repeated-call safety, or whether any side effects occur; these are not fully covered elsewhere since no annotations exist.

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

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

A single sentence with no filler. The key action and behavioral distinction ('without waiting') are front-loaded, and the source of the job_id is stated efficiently. No wasted words.

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

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

For a simple one-parameter tool with an output schema, the description is nearly adequate. It gives the parameter source and the non-waiting behavior, while the output schema likely covers return values. It omits error handling and alternative routing, but these are less critical given the sibling tools and simplicity.

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

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

Schema description coverage is 0%, so the description must compensate. It does so by specifying the provenance of job_id – it is the identifier returned by generate_image/edit_image – which is contextual meaning the schema lacks. It does not describe format or constraints, but for a single required parameter this is valuable guidance.

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

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

The description uses a specific verb ('peek') and a clear resource ('a job returned by generate_image/edit_image'), immediately conveying that this tool checks job status. The phrase 'without waiting' effectively distinguishes it from siblings like wait_for_job and fetch_result.

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

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

The description gives clear context by stating the tool is for peeking without waiting, implying it is the non-blocking counterpart to wait_for_job. It also establishes that the job must have been created by generate_image or edit_image. It does not explicitly enumerate alternatives or exclusion cases, but the primary usage context is clear.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states that the tool is a listing operation returning models with readiness and installed ComfyUI items, which is transparent about its read-only nature. However, it does not mention potential latency, output size, or any side effects. The behavior is adequately conveyed but not enriched beyond the literal action.

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 sentence that front-loads the main action ('List the image models') and packs in the key detail about `model` keys. It is a bit dense with the second clause about ComfyUI installations, but every part contributes meaning. No filler words.

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

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

Given the tool's simplicity (zero params) and the presence of an output schema, the description is complete enough to call the tool correctly. It explains what will be returned (models with readiness, plus installed items) and why the output matters (`model` parameter keys). No critical information is missing for correct invocation.

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

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

The tool has zero parameters, so the schema provides no parameter semantics. The description adds value by explaining that the output contains keys for the `model` parameter elsewhere, giving the output practical meaning beyond a bare list. This exceeds the baseline of 4 for zero-parameter tools.

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 specifies exactly what the tool does: it lists image models the server can drive, with readiness, and everything ComfyUI has installed. The mention of 'keys for the `model` parameter' clearly ties the output to model selection for generation/editing tools, distinguishing it from siblings like server_status or job_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 when to use this tool: when you need valid values for the `model` parameter. This is clear context, though it does not explicitly say 'use before generate_image' or name alternatives. It gives enough context for an agent to infer the appropriate use case.

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 a significant behavioral trait: 'this MCP always queues behind it,' indicating that calls to this tool will queue behind any running job on the server. It also clarifies the read-only nature of checking status (reachability, version, memory, queue), with no destructive actions implied. This goes beyond a generic 'check status' statement and provides useful 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 a single, information-dense sentence that leads with the action ('Check the ComfyUI server:') and then lists the specific check items. The queueing behavior is added as a parenthetical note, keeping the structure compact without redundancy. Every part earns its place.

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

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

For a tool with no parameters and an output schema, the description fully captures what the agent needs to understand before calling it: what can be checked, what the queueing behavior is, and implicitly that it is a non-destructive status probe. Nothing critical is missing; the output schema covers return values, so the description need not explain them.

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

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

The tool has zero parameters, so the schema is complete (coverage 100%). Per the rubric, a zero-parameter tool gets a baseline of 4, and the description does not need to add any parameter semantics. There is nothing missing or ambiguous about parameters.

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

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

The description states a specific verb ('Check') and a clear resource ('ComfyUI server'), then enumerates the exact things checked (reachability, version, GPU memory, queue length, and whether someone else's job is running). This makes it unambiguous what the tool does and naturally distinguishes it from sibling tools like generate_image or job_status, even though no sibling is named.

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 – an agent would infer that this is for checking server status before or during operations – but it does not explicitly say when to use it versus alternatives. There is no mention of 'use this to verify server health before submitting a job' or any exclusions. The queueing behavior hints at a practical consideration, but the when-to-use guidance is implicit rather than explicit.

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

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

With no annotations provided, the description carries the full burden and does well: it discloses blocking behavior, the timeout limit, and the two possible return payloads. It could additionally indicate what happens on error or whether this has side effects, but for a waiting operation the behavior is clearly communicated.

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

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

The description is a single efficient sentence with no filler. It front-loads the core action and timeout, then the return behavior, earning every word it uses.

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

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

The core behavior and return values are covered, which is good given there is no output schema. However, for a tool with zero annotation and schema description coverage, the missing parameter explanations and lack of guidance for choosing this over job_status leave meaningful 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 0%, so the description needed to explain all three parameters. It only mentions `timeout` in seconds and the notion of a saved path, which indirectly relates to `save`, but it never defines `job_id` or the exact meaning/effect of `save` as a boolean.

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

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

The description states a specific action ('Block up to `timeout` seconds') on a specific resource ('a job'), and explains the two possible return outcomes. This clearly distinguishes it from siblings like job_status and fetch_result by emphasizing the blocking wait behavior.

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 when to use this tool: when you want to block until a job completes, with a timeout fallback returning the status JSON. However, it never explicitly contrasts this with non-blocking alternatives like job_status or explains when someone should prefer one over the other.

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