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

With no annotations at all, the description carries the full behavioral burden, and it does disclose the return shape — JPEG previews per result plus URL and id of the full-resolution PNG — which is information an agent cannot get elsewhere since there is no output schema. It omits cost, latency expectations (except what quality hints at in the schema), and whether results are retained or how long the returned URLs live.

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 short sentences, front-loaded with the capability, then the single-image case, the multi-image case, and the return format. Every sentence carries distinct information and the example phrasings are short enough to be read rather than skipped.

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 ten-parameter mutation tool with no annotations and no output schema, the description covers the essentials: what it does, how to prompt for both modes, and what comes back. The gaps — no explicit routing to generate_image, no cost or timing, no mention of optional knobs like boxes or quality — are real but secondary given how much the 100%-covered schema carries.

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 documents all ten parameters including boxes, count, quality, and enhance_prompt, making 3 the baseline. The description reinforces prompt semantics with worked examples ('the woman from the first image standing in the forest from the second image'), which adds real value beyond the terse schema text, but it never touches boxes, quality, or count.

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?

States a specific verb and resource ('Edit an image, or combine several reference images') plus the backing model, and the one-vs-many framing immediately conveys the two modes. It stops short of explicitly contrasting with generate_image, which is the closest sibling and the main source of confusion for an agent choosing between creating and editing.

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 genuinely useful in-tool guidance: how to phrase a single-image edit and how to reference multiple images by order, with concrete example phrasings. It says nothing about when to pick this over generate_image, upscale_image, or remove_background, and no exclusions or prerequisites (e.g., that images are required, source of those images) are stated.

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

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

With no annotations, the description carries the full burden. It does disclose the return shape (JPEG preview plus URL and id of the full-resolution PNG), which is valuable, but says nothing about generation latency, cost, failure modes, or how count variations are returned.

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 short sentences with zero waste; the purpose is front-loaded and the return-value and follow-up details come after. 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?

For a 9-parameter generation tool with no output schema, the description covers the two things the schema cannot: what comes back and how to chain into edit_image. Latency and cost expectations are the main remaining gap.

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

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

Schema description coverage is 100%, so the schema already documents prompt, quality, seed, boxes, and dimensions thoroughly. The description adds no parameter-level meaning beyond what is structured, so the baseline 3 applies.

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

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

States a specific verb and resource (generate images from a text description) and names the model used. It is distinguishable from edit_image because it names that sibling as the refinement path, but it does not explicitly contrast generation-from-scratch with editing.

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 only routing guidance is the closing sentence pointing to edit_image for refinement of a returned id – useful for the follow-up step, but it never states when to choose this tool over its siblings for an initial request or what prerequisites exist.

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

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

With no annotations, the description carries the full burden and does reasonably well: it names the returned fields (preview, URL, prompt, seed, upsampled caption, model) and the default behavior when no id is given. It omits access/permission behavior and error cases when an id is invalid.

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 content is front-loaded with the main action and return contents, followed by the default and recovery case. Every sentence is relevant, though the phrasing is slightly dense.

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 single-parameter read tool with no output schema, the description explains return contents and the no-id default, which is sufficient to invoke it correctly. Minor gaps around invalid-id behavior and permissions keep it from a 5.

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

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

Schema coverage is 100%, so the schema already defines the single 'image' parameter and its default. The description only restates the empty-id default behavior, adding little beyond structured data; baseline 3 applies.

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

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

The description gives a specific verb and resource (show a stored image) plus a secondary purpose (how it was made). It implicitly distinguishes retrieval from generate_image/edit_image, though it doesn't name any sibling 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?

It states a concrete usage condition: without an id it returns the most recent image, and it names a recovery use case for client-side timeouts. There is no explicit when-not or named alternative, but the context is clear.

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

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

No annotations exist, so the description carries the burden; it does convey that this is a pure enumeration with no mutation of files. However, it says nothing about whether the results reflect on-disk models vs. loaded models, whether the server must be reachable, or how the two resources are separated in the response.

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

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

A single front-loaded sentence with no filler; both returned resource types are named up front. 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?

With no parameters and an output schema present, the description needn't explain the return shape, and it correctly identifies what is listed. The only missing piece is the operational precondition (a reachable ComfyUI server) and the distinction from server_status.

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 takes zero parameters, so the baseline is 4 and there is nothing further the description needs to document. Nothing in the description conflicts with the empty schema.

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

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

States a specific verb ('List') plus two concrete resources: the server's workflows and the model files ComfyUI can see. An agent can tell this is a discovery/enumeration call, though it never explicitly contrasts itself with the similarly-named sibling server_status or unload_models.

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

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

Usage is only implied — an agent can infer this is the discovery step before generate_image or edit_image, but the description never says when to call it, when not to, or which sibling covers overlapping information. No prerequisites (e.g. server must be running) are noted.

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

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

With no annotations, the description carries the full burden, and it does add real value: it discloses the output artifact (transparent PNG), the preview-on-white rendering quirk, and the returned URL and id. However, it says nothing about latency or model-loading behavior, which matters given the unload_models sibling, nor about input limits or failure modes.

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

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

Two tightly-written sentences: the operation and model come first, the return contract second. Every clause carries information 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?

No output schema exists, but the description compensates by naming the return type, preview rendering, URL and id. For a one-parameter read-like transform tool this is nearly sufficient; only execution cost/model-loading context is missing.

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

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

There is a single required parameter and schema description coverage is 100%, so the schema already explains that 'image' accepts a server image id or an http(s) URL. The description adds nothing parameter-specific beyond implying a single main subject, so baseline 3 applies.

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

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

States a specific verb ('cut out') and resource ('main subject') with a concrete effect ('make the background transparent'). It also names the underlying model (BiRefNet), and no sibling (edit_image, upscale_image, generate_image) performs background removal, so the agent can select it unambiguously.

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

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

Usage is only implied by the operation name and the phrase 'main subject' – the agent can infer it takes an existing image and removes the background. There is no explicit statement of when to prefer this over edit_image, nor any exclusions or prerequisites (e.g. images with multiple subjects).

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 behavioral burden. 'Report' strongly implies a read-only operation, and the listed checks (up status, queue, memory, model loading) add useful scope, but there is no explicit statement that the tool is non-mutating, has no side effects, or has no auth/rate-limit 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?

A single front-loaded sentence with no filler. Every clause maps to a concrete status signal the tool reports.

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

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

For a zero-parameter status tool with an output schema, the description is nearly complete: it lists the core status dimensions an agent would need before invoking it. It falls short only by omitting explicit read-only/no-side-effect context, which matters because no annotations are present.

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 takes zero parameters, so the baseline is 4. The description correctly does not discuss parameter semantics, and there is nothing missing because no inputs exist.

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 ('Report') and resource (ComfyUI server status), and enumerates the exact signals returned: uptime, queue, free memory, and loaded-model status. It is clearly distinguishable from the action-oriented siblings such as generate_image and unload_models, though it does not explicitly name or contrast them.

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

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

The description explains what the tool reports but gives no explicit guidance on when to call it, when not to call it, or which sibling to use instead. An agent can infer that this is a health-check tool, but that inference is not stated.

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

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

With no annotations, the description carries the full burden and does well: it discloses the side effect (memory freed), the cost (models reload on the next request, which is slower), and that this is normally automatic. It does not say whether in-flight requests are interrupted or whether all loaded models or only some are unloaded, which is a real gap for a state-changing operation.

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 short lines with the action front-loaded and the consequence and default behavior following in descending order of importance. Every sentence contributes new information; nothing is padding.

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?

An output schema exists and there are no parameters, so the description only needs to cover behavior, which it does: effect, reload penalty, and automatic fallback. The remaining gap is concurrency/interruption semantics for a mutation-style tool with no annotations to lean on.

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 takes zero parameters, so per the baseline this scores 4. Nothing in the description is needed to explain inputs, and it correctly mentions a scope qualifier ('the image models') rather than implying any selectable argument.

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?

States a specific verb and resource: 'Free the GPU memory held by the image models'. No sibling tool (generate_image, upscale_image, list_models, server_status) deals with memory lifecycle, so the purpose is unmistakably distinct without needing an explicit comparison.

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?

'Free ... now' plus the note that the server already does this automatically after an idle period implicitly tells the agent that manual invocation is only warranted when memory must be reclaimed immediately. That is clear context, but it stops short of an explicit when-to-use / when-not-to-use statement or escalation guidance.

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

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

With no annotations, the description carries the full burden and does well: it discloses expected latency ('takes a few seconds') and the return shape (preview plus URL and id of the full-resolution PNG). It leaves unstated whether a new image is persisted or how it interacts with the source image, and no output schema exists to fall back on.

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 short sentences, front-loaded with the action and scaling choices, followed by the differentiator, latency, and return value. No filler or restated title.

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 two-parameter tool with no annotations and no output schema, the description covers purpose, latency, and return values, which is nearly everything an agent needs. The remaining gap is input-source behavior (id vs URL) and whether results are persisted or return-only.

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

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

Schema description coverage is 100%, and the enum for factor is already fully documented, so the description only echoes the 2x/4x choice. It adds nothing about the 'image' parameter, such as what happens when a stock/server id versus a remote http(s) URL is supplied.

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?

States a specific verb and resource ('Enlarge an image 2x or 4x') and names the underlying model (Real-ESRGAN). The clause 'Adds sharpness rather than new content' cleanly separates it from the sibling generate_image and edit_image, so an agent can route without opening a schema.

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

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

Gives a concrete use case ('prints and wallpapers') and a negative qualifier that rules out content-adding scenarios, which implicitly points at generate_image. It stops short of explicitly naming when not to use it (e.g., small inputs, non-photo assets) or naming alternatives by name.

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