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

Discloses that the tool checks connectivity and returns node count and device/VRAM. It also warns about failure implications. No annotations exist, so the description carries the full burden, but it omits potential side effects or permissions.

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

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

Two concise sentences that front-load the purpose and immediately provide failure guidance. No wasted words.

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

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

Given zero parameters and an existing output schema, the description fully covers the tool's behavior, including its role in a loop, return data, and failure implications.

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

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

No parameters exist, so baseline 4 applies. The description adds value by explaining the return values (installed-node count, device/VRAM) beyond the input schema.

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

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

The description uses specific verb 'confirm' and resource 'ComfyUI reachability', clearly stating the tool's purpose as a connectivity check. It distinguishes from sibling tools like 'system_stats' by focusing on reachability and loop integration.

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

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

Provides clear guidance: use for initial connectivity check, and if it fails, do not guess node names. However, it does not explicitly contrast with other tools like 'system_stats' or 'get_node' for when not to use.

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

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

No annotations provided, but the description details both modes (side_by_side layout, difference formula with visual result) and the amplify parameter effect. Does not explicitly state it is read-only but implies it.

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

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

Front-loaded with purpose, uses bullet-like structure. Somewhat lengthy but each part adds value; could tighten file parameter explanation.

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, no output schema, and 6 parameters, the description covers key behavioral details (mode, amplify, use case) but omits file parameter semantics and return value information, leaving gaps.

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

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

Schema coverage is 0%, so description must compensate. Explains mode and amplify well (2 of 6 parameters), but leaves filename_a, filename_b, subfolder_a, subfolder_b undocumented. Partial 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 tool compares two images ('See what changed between two passes') and ties it to a loop step, distinguishing it from siblings like image_diff_stats (numerical stats) and get_image (retrieve).

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

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

Provides practical guidance: use every pass against your best-so-far, and explains when to use each mode. Lacks explicit when-not-to-use or alternative tools, but context is strong.

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 fully carries the behavioral disclosure burden. It explicitly declares the tool is 'Read-only' and details the steps: fetches template, lists node classes, subtracts what's installed, and reports missing nodes with pack IDs. This provides full transparency about inputs, process, and outputs without contradiction.

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

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

The description is concise, with two clear paragraphs: the first states the core purpose, and the second elaborates the process. Every sentence adds value without fluff. It is front-loaded with the main action.

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

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

Given that the tool has an output schema (not shown but indicated), the description does not need to detail return values. It covers the tool's purpose, process, and relation to siblings. It explains dependencies (template, object_info, registry mapping). The only gap is parameter documentation, which is evaluated separately. Overall, it provides sufficient context for 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?

The input schema has 0% description coverage. The description only mentions 'same args as get_template', which adds minimal context by referencing another tool but does not explain the meaning or usage of the individual parameters (name, pack, source). This is insufficient for an agent to understand parameter semantics without external knowledge.

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 function: 'Diff a template's nodes against what's installed, and resolve each missing node to the pack that provides it'. It specifies the action (diff and resolve) and resource (template nodes vs installed). This distinguishes it from siblings like get_template (fetches template) and install_node_pack (installs packs).

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 states it uses the same args as get_template, implying it should be used after fetching a template and before installing missing nodes with install_node_pack. It notes the process of subtracting installed nodes, guiding usage context. However, it does not explicitly state when not to use it or mention alternatives beyond referencing siblings.

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 full responsibility. It details the transformation process (inflating, mapping, resolving links) and discloses limitations (best-effort, skipped subgraphs, widget drift leading to errors). However, it does not explicitly state whether the operation is read-only or has side effects.

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

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

The description is concise, front-loaded with the main purpose, and each sentence adds value without redundancy. It efficiently conveys the tool's function, best-effort nature, and post-processing advice.

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 that an output schema exists, the description need not explain return values. It covers the conversion process, edge cases (skipped nodes, widget drift), and provides guidance. It is reasonably complete for a converter tool, though it could mention prerequisites like live object_info.

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 has 0% coverage for the single parameter 'flowzip', so the description must compensate. It explains that the parameter is a FlowZip or litegraph and can be inflated, which adds meaning beyond the empty schema. However, it lacks details on format, encoding, 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 starts with a clear verb 'Convert' and specifies the resource 'FlowZip (or litegraph)' with a target format 'API/prompt format ready for submit_workflow'. It distinguishes itself from siblings like inflate_workflow and submit_workflow by describing its bridging role.

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

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

The description states that this tool is intended for authoring/adapting graphs compactly and as a step before submitting workflows. It provides guidance on handling errors ('review the API graph before running') but does not explicitly compare to alternatives or specify when not to use it.

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

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

The description discloses that the tool returns the actual image to the model, implying a read-only retrieval. Since no annotations are provided, the description carries the full burden for behavioral disclosure. While adequate for the core behavior, it omits potential side effects (e.g., does it consume the image? is there caching?) and does not address authentication 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 two paragraphs with some repetition (e.g., 'loop step 3: LOOK — part 2' revisited). It could be more concise by merging the first sentence and the loop context. Overall, it is somewhat verbose for the information conveyed.

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 three parameters with no schema descriptions and no output schema, the description leaves significant gaps: it does not explain which parameter is required (filename), what format identifiers take, or what the response contains. For a tool that returns binary image data, the absence of error handling or type hints is a deficiency.

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 provides zero information about the three parameters (filename, subfolder, image_type). With 0% schema description coverage, the description must compensate but fails entirely. The agent receives no guidance on how to specify which image to fetch, making correct invocation difficult.

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 fetches a rendered output image for visual inspection, using active verbs like 'Fetch' and 'LOOK'. It distinguishes itself from siblings by embedding the tool in a loop workflow (step 3: LOOK), though it does not explicitly compare with similar tools like 'compare_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 explicit usage context: this is part of a loop where the agent should view pixels and judge against the brief before re-running. It advises against declaring workflow done based on a green run alone. However, it lacks explicit when-not-to-use or mention of alternatives like 'compare_images' for comparison tasks.

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?

Tool has no description.

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

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

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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?

Tool has no description.

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?

Note is a read operation, no params, output schema exists. Description does not explicitly confirm read-only nature or mention side effects, but tone suggests no destructive actions. Adequate given simplicity.

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

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

Single sentence with clear subject and action. No extraneous information. Front-loaded.

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

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

Given zero parameters and presence of output schema, description is complete enough. No additional details 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?

No parameters exist; schema coverage is 100%. Description adds nothing beyond schema, but baseline for 0 parameters is 4.

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

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

Description clearly states the tool shows running and pending items in ComfyUI's execution queue. Verb 'show' and resource 'execution queue' are specific. Distinguishes from siblings like 'submit_workflow' and 'interrupt'.

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?

Description implies use when checking queue status but does not explicitly state when to use or compare with alternatives like 'system_stats' or 'check_comfyui'. No exclusion criteria.

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

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

No annotations provided, so description carries full burden. It discloses blocking behavior up to timeout_s and polling, but does not mention error handling, rate limits, idempotency, or whether it's read-only. Basic behavioral info is present.

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

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

The description is two sentences with a clarifying note. It is efficient and front-loaded with the core action, though the loop reference adds some extraneous context for a multi-step process.

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 polling tool with two parameters and an output schema, the description covers the core behavior (blocking, output format, follow-up with get_image). It lacks details on error cases or timeout handling, but the output schema likely documents return values.

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 has 0% description coverage, so description must compensate. It explains timeout_s as the blocking duration, and the prompt_id is implicitly the identifier for the submitted prompt. This adds meaning beyond the schema's titles.

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 polls /history for a submitted prompt and returns output files, specifying the action (poll), resource (history for a prompt), and result (output files). It distinguishes from siblings like get_image (which views pixels) and get_node (which gets node info).

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 says to use after submitting a prompt, blocks up to timeout_s, and directs to feed outputs to get_image. It implies when to use but does not explicitly state when not to use or mention alternatives.

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

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

No annotations present, so description fully carries the burden. Discloses that output is litegraph format (not API), token reduction stats, and that online templates require node/model verification.

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?

Well-structured with front-loaded purpose, then clear bullet-like explanation of parameters and usage context. Every sentence adds value.

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 (4 parameters, output schema exists, sibling tools like search_templates and run_template), the description is complete. It explains the output format, prerequisites, and next steps.

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%, but description explains all four parameters in detail: name, source (behavior of online vs installed), pack (required for installed), and fmt (flowzip vs json, with token savings). Adds significant meaning beyond schema.

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

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

Clearly states the verb 'Fetch', resource 'workflow template', and distinguishes between online and installed sources. Does not explicitly differentiate from sibling 'search_templates' but provides enough context to avoid confusion.

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

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

Provides explicit guidance on when to use online vs installed, flowzip vs json, and mentions post-fetch steps like adapting to API format or checking nodes/models via other tools.

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 the return values (statistical metrics) and implies a read-only operation, but does not explicitly state that the tool does not modify files or require special permissions. The warning about catching unintended changes adds some transparency, but more explicit statements about safety and side effects would improve it.

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

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

The description is two sentences with a line break, each sentence adds value. It is front-loaded with the core purpose and includes a memorable phrase ('I changed only what I meant to' gate) that helps recall. No extraneous information.

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

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

The description covers the main return values and the relationship with a sibling tool. However, it fails to address how the optional subfolder parameters affect behavior or defaults. Since an output schema exists (not shown), the return structure can be assumed documented, but parameter usage 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?

Schema description coverage is 0%, meaning the input schema lacks descriptions for all 4 parameters. The description does not mention any parameter names, purposes, or usage details (e.g., what filename_a and filename_b refer to, or how subfolders work). For a tool with 4 parameters and no schema descriptions, the description must compensate, but it provides zero parameter 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 clearly states that the tool quantifies change between two image passes, returning mean/max absolute difference and percentage of pixels changed. It differentiates from the sibling CompareImages by explaining that CompareImages shows what changed while this tool shows how much, and it warns about detecting unintended large changes.

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

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

The description explicitly recommends pairing with compare_images and explains the complementary roles (what vs. how much). It does not provide explicit when-not-to-use scenarios, but the context is sufficiently clear for an AI agent to decide when to invoke this tool over alternatives.

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

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

No annotations provided, so description carries full burden. It discloses that structure (nodes, types, links, widget values) is preserved while cosmetic fields are not, clearly detailing behavioral traits beyond schema. Minor omission: no mention of error handling or side effects.

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

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

Three concise sentences: first describes action, second specifies preservation, third gives post-processing steps. No wasted words, front-loaded.

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

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

Given one parameter and an existing output schema, the description covers input, behavior, and next steps adequately. Could mention potential errors from invalid flowzip, but overall complete for the tool's complexity.

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

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

With 0% schema description coverage, the description compensates by explaining that 'flowzip' is FlowZip text from get_template. It adds meaning about the parameter's origin and format beyond the schema type string.

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

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

Clearly states 'Expand FlowZip text back into a full litegraph workflow JSON' and distinguishes from siblings like get_template (which produces FlowZip) and flowzip_to_api (which converts to API format). Verb 'expand' and resource 'FlowZip to litegraph JSON' are specific.

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

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

Explicitly indicates it is the reverse of get_template and that the output must be adapted for submit_workflow, providing context on when to use. Could be more explicit about alternatives, but effectively guides the agent.

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

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

No annotations provided, yet description covers key behaviors: no restart needed, async continuation, and trust/whitelist source. Lacks specifics on error handling or permissions, but provides substantial transparency 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?

Three sentences, no redundancy, front-loaded with the main action. Every sentence adds value: the how, the constraints, and important behavioral notes.

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 existence of output schema (not shown), return values need not be explained. The description covers parameter source, folder destination, async behavior, and verification step. Could mention failure modes, but overall adequate for context.

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?

Only one parameter 'name' with 0% schema description coverage. The description adds crucial semantic context: the name must be an exact catalog name from search_models. This compensates well for 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 action (download/install), the resource (model from catalog), and the destination (models/<type>/ folder). It distinguishes from nodes (no restart needed) and references sibling tool search_models for exact name, making intent and scope unmistakable.

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

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

Explicitly tells to use exact name from search_models and to verify with list_models after completion. Also warns about large model download times and server-side continuation. Does not explicitly say when not to use, but the context is clear enough.

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

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

With no annotations, the description fully discloses the behavior: queues, starts, polls, requires restart, and fails on security blocks. Mentions trust and safety, providing clear expectations for the agent.

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

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

Two concise sentences plus a brief note; every sentence adds value. Front-loaded with core action and key constraint, then details the process and post-condition.

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?

Covers the full workflow: queueing, polling, restart requirement, and error handling. Output schema exists, so return value explanation is unnecessary. Complete for an agent to use 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?

Explains pack_id as the registry id from find_missing_nodes, but does not clarify the version parameter (its default 'latest' is only in schema). Schema coverage is 0%, so description partially compensates but leaves a 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?

Clearly states the tool installs a custom-node pack using its ComfyUI-Manager registry id, specifying the source as 'trusted registry' and referencing find_missing_nodes for the id. Distinguishes from sibling tools like install_model and find_missing_nodes.

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?

Indicates the tool should be used for trusted registry packs, mentions the prerequisite of obtaining the id from find_missing_nodes, and advises a subsequent restart via restart_comfyui. Does not explicitly state when not to use, but the context implies avoidance for arbitrary code.

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

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

No annotations provided; the description lacks any behavioral details beyond the action itself, such as side effects, reversibility, or state requirements.

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

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

The description is a single, concise sentence that front-loads the essential information with no unnecessary words.

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

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

Given the tool has no parameters and a straightforward purpose, the description is mostly complete. However, it could mention expected state or result beyond the action.

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

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

No parameters exist (schema coverage 100%), so the description does not need to add parameter information. Baseline score of 4 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 clearly states the tool cancels the currently executing prompt, specifying the action and target. It distinguishes from sibling tools like 'submit_workflow' or 'loop_start'.

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 using the tool to stop execution, but does not explicitly state when not to use it or provide alternatives. Context from siblings suggests a clear 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?

Despite no annotations, the description discloses how the tool works: it reads the loader's enum from object_info, handles both legacy list and COMBO encoding, and reports every enum-typed input if input_name is omitted. This provides good transparency, though it could mention the output format (which is covered by output 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 succinct yet informative: a single sentence for purpose, then technical details, then usage warning. Every sentence adds value without repetition. It is well-structured and easy to read.

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, the description provides sufficient context: purpose, technical behavior, parameter guidance, and a caution. An output schema exists to cover return values. It could include an example or mention of expected response, but overall it is complete enough for an agent to use 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?

The input schema has 0% description coverage, so the description must compensate. It explains the effect of omitting input_name (reports all enum-typed inputs) and implies that class_name identifies the loader. However, it does not fully describe class_name, and the description is incomplete for the class_name parameter.

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: 'List the real model files a loader offers'. It specifies the resource (model files) and action (list), and adds context about avoiding hallucination. This differentiates it from sibling tools like search_models (which searches) and install_model (which installs).

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 explicit guidance: 'never hallucinate a checkpoint/LoRA/VAE filename' and 'Pick ONLY from the returned list'. It explains when input_name can be omitted to get all enum-typed inputs. However, it does not explicitly mention when not to use this tool or suggest alternatives.

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

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

Given no annotations, the description fully discloses behavior: dual matching, case sensitivity, display name vs class name distinction, count-only mode when keyword omitted.

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?

Concise, front-loaded with main purpose, every sentence adds value. 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?

Given one optional parameter and an output schema, the description covers input behavior, return format, and edge cases (omitting keyword). Complete for the tool's complexity.

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

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

With 0% schema coverage, the description explains the 'keyword' parameter meaning and behavior (optional, default empty, count mode). Adds significant value beyond schema.

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

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

Clearly states 'Search installed nodes by keyword' and distinguishes from siblings like 'get_node' and 'find_missing_nodes'. Specifies matching against class and display names, and returns a mapping.

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

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

Provides context for usage: keyword search, and omitting keyword for count. Does not explicitly list when not to use, but sibling differentiation is implied by description.

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?

Describes the tool as the 'source of truth' implying authority and reliability, but does not disclose side effects or read-only nature given no annotations.

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

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

Three sentences with no waste: purpose, when to use, and a behavioral trait. Excellent front-loading.

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 existence of an output schema, the description adequately covers purpose and usage, though it could mention the return value type.

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%, and the description adds no meaning to the `run_id` parameter beyond the schema's title 'Run Id'.

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

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

The description clearly states it fetches the best-so-far graph for reverting or delivery. However, it does not differentiate from sibling loop tools like loop_finish or loop_start.

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

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

Explicitly recommends use after compaction or when unsure about the current graph's validity. Lacks a direct 'when not to use' statement.

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 fully discloses behavior: it closes the loop, marks convergence, returns final ledger and best graph, and instructs the agent to stop. No contradictory or missing behavioral aspects are present.

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

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

The description is two sentences, front-loads the main action, and contains no extraneous words. Every sentence is meaningful and earns its place.

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

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

Given the presence of an output schema, the description need not explain return values. It covers purpose, guidelines, and behavior well. However, the lack of parameter documentation is a gap, slightly reducing completeness.

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

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

Schema description coverage is 0%, and the description does not mention the parameters 'run_id' or 'summary'. It fails to add meaning beyond the input schema, which is critical given the low coverage. The agent must guess the purpose of these 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 clearly states the verb 'close the loop' and the resource 'convergence checkpoint', and explains that it marks the run as converged and returns the final ledger and best graph. This distinguishes it from sibling tools like loop_start and loop_record, which are for earlier stages.

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?

Explicit usage guidance is provided: after convergence, stop and ask for user approval. It warns against continuing to invent variations, which is a clear when-not-to-use instruction.

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 describes the tool as read-only ('append-only', 'read it') and discloses the content: what changed, what it did. It also explains behavioral context (recover thread, avoid retries, best pass). This provides sufficient transparency for an agent.

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

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

The description is concise (three sentences) and front-loaded with the core purpose. Each sentence adds value: stating it is append-only, describing its contents, and listing use cases. There is no wasted text, though the parameter is entirely unaddressed.

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 (one required parameter) and the presence of an output schema (documenting return values), the description adequately covers purpose and usage context. However, the lack of parameter explanation is a notable gap. The description would be complete if it briefly mentioned that run_id identifies the loop session.

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 only parameter, run_id, has no schema description (0% coverage) and the tool description does not explain what run_id represents or how to obtain it. The description focuses on the tool's output and usage context, not the input parameter. This leaves the agent without guidance on what value to provide.

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 is an append-only loop log that records each pass, what changed, and what it did. It specifies the purpose: read after context compaction to recover thread, avoid retrying dead ends, determine best pass, and provide user sign-off. This distinguishes it from sibling tools like loop_record (which likely records) and loop_report (which likely summarizes).

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

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

The description explicitly states when to use the tool: 'Read it after a context compaction to recover the thread' and 'hand to user at sign-off'. It implies it is for reading only, but does not explicitly mention when not to use it or alternatives. The purpose is clear enough that usage context is well-understood.

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 must disclose behavioral traits. It explains the revert behavior on 'worse'/'same,' the requirement for graph with 'better,' and the role of score. It also mentions passing outputs for loop_report. However, it does not explicitly describe side effects or error handling, but the key behaviors are covered.

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 somewhat lengthy but well-structured, with bullet points for parameters and clear explanations. It front-loads the purpose. Minor redundancy (e.g., 'Never build on a regression' is reiterated) could be trimmed, but overall it is efficient.

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

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

Given the complexity of the tool (7 parameters, loop context) and the presence of an output schema, the description covers the essential aspects: input parameter behavior, decision logic, and the revert mechanism. It does not detail return format, but the output schema likely handles that. The description is sufficient for an agent to use the tool correctly.

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

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

Schema description coverage is 0%, so the description must add meaning for each parameter. It explains 'change' as the modification made, 'outcome' as verdict vs best-so-far, 'graph' as required when outcome is 'better,' 'score' as an objective measure for gates, 'outputs' as files for loop_report, and 'note' and 'run_id' implicitly. This provides significant 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 tool's purpose: 'Record a pass and apply the ratchet (loop step 5: DECIDE).' It specifies the verb 'Record a pass and apply the ratchet' and the resource 'loop step 5.' The purpose is distinct from sibling tools like loop_start, loop_best, loop_finish, etc.

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 guidance on when and how to use the tool. It explains that on 'worse' or 'same' outcomes, the best graph is returned and a different change should be tried. It also notes that graph is required when outcome is 'better,' and explains the role of score in decision-making. This distinguishes usage from alternatives.

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

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

With no annotations provided, the description solely discloses key behaviors: images are downscaled and base64-inlined, the page can render offline or via email, and output is written next to the run state by default with optional out_path. This covers important traits beyond the schema, though permissions or performance are not addressed.

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

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

The description is concise and well-structured: it starts with the primary purpose, explains why this artifact is important, then provides technical details about image handling and output location. Every sentence adds value without being verbose.

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 that an output schema exists (though not shown), the description need not explain return values. It covers the tool's purpose, usage, output format, and file location. However, it does not indicate whether the result is a success message or status, which might be useful.

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 has 0% description coverage, but the description explains that out_path can be set to place the report anywhere, adding meaning beyond the schema's default string type. The run_id parameter is implied by context (the run to report), but no explicit description is given. This is adequate but not rich.

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 renders the entire run as a self-contained HTML page, detailing what changed, was kept, reverted, and final. This is specific to generating a final report, distinguishing it from siblings like loop_best or loop_record which handle other aspects of the loop workflow.

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

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

The description provides clear context for when to use the tool: at the sign-off checkpoint alongside the result, emphasizing the artifact's value as evidence of convergence. However, it does not explicitly state when not to use it or reference alternative tools, though the purpose is sufficiently distinct.

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

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

No annotations provided, but description covers key behavioral traits: returns run_id, stores best graph externally for persistence across compaction, enables reversion. Does not mention authorization or rate limits, but adequate for a start tool.

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

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

Three paragraphs with clear structure: imperative instruction, parameter explanations, return value and significance. Concise but could be slightly tighter; no wasted sentences.

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?

Fully covers purpose, usage timing, parameter semantics, return value (run_id), and behavioral significance. Output schema exists but description adds value beyond it. Complete for a start tool.

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

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

Schema has 2 params with 0% description coverage, but description adds substantive meaning: 'brief is what right means' and 'gate is the objective test'. Compensates for lack of schema-level descriptions.

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

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

Clearly states it opens a loop run, with specific verb+resource ('Open a loop run'). Distinguishes from sibling tools like loop_record, loop_best, etc. by explaining this is step 0.

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?

Explicit timing instruction: 'do this BEFORE the first submit'. Explains when to use 'gate' (if brief has objective test) vs leave empty. Does not explicitly mention when not to use, but context of siblings provides differentiation.

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

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

The description explains what each metric measures (e.g., tile_seam compares wrap-around join to interior join). However, it does not explicitly state if the tool is read-only or if it requires specific permissions, though this is implied by its measurement nature.

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 relatively concise but uses line breaks and dashes that may not render well in all contexts. It is front-loaded with the main purpose, and each sentence adds value.

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 existence of an output schema (not described) and no annotations, the description covers the main use case well. However, it does not mention the return type or output schema, and lacks explanation of 'objective test'.

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 only adds context for the metric parameter by listing values and meanings. It does not explain the filename or subfolder parameters, leaving them solely to 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 tool's purpose: 'Score an output objectively' for specific metrics (sharpness, tile_seam, brightness). It distinguishes itself from siblings by focusing on objective measurement for the ratchet system.

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

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

Explicitly states when to use: 'Use ONLY where the brief has an objective test' and advises feeding scores to loop_record. Also warns that 'A score is not the judgement' and to use eyes, providing clear context and 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?

No annotations provided, so description carries full burden. Discloses that server is briefly unavailable and recommends polling check_comfyui. Adequately transparent for a restart 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?

Two sentences, front-loaded with purpose and context, no wasted words. 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 no parameters and existing output schema, description covers why, side effect, and follow-up. Could mention output schema content but not required.

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?

Input schema has zero parameters, baseline is 4. No additional parameter info needed, description handles purpose and behavior.

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

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

Clearly states 'Restart ComfyUI', a specific verb+resource, and explains the purpose: to register newly installed nodes in /object_info. Differentiates from siblings like check_comfyui and install_node_pack.

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?

Implies usage after installing nodes to register them, and explicitly tells agent to poll check_comfyui after restart. No explicit when-not-to-use, but 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 provided, so the description carries full burden. It details the internal steps (fetch, convert, apply overrides, submit), discloses the converter coverage (~88%) and that skipped nodes are reported. It does not explicitly state whether the operation is read-only or modifies state, but the context implies it executes a run (non-destructive). Overall, good behavioral disclosure beyond the missing annotations.

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

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

The description is relatively concise and well-structured: purpose, usage, overrides format, post-run steps, and limitations. Minor informal phrasing ('LOOK') but adds clarity. Could be slightly tighter, but effectively communicates essential information without verbosity.

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 presence of an output schema (context signal), the description does not need to detail return values. It provides sufficient context: prerequisites (template_slots, find_missing_nodes), the process, limitations (subgraph, converter coverage), and post-run actions. Lacks explanation of 'pack' and 'source' but defaults are provided. Reasonably complete for a complex tool.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the 'overrides' parameter in detail (format: {node_id: {input_name: value}} and source from template_slots). However, it does not explain 'pack', 'source', or 'client_id' beyond default values. While overrides is the most complex parameter, the lack of explanation for others reduces the 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 specifies the action ('Run a known-good template with input overrides') and resource ('template'), distinguishing it from siblings like 'submit_workflow' and 'get_template'. It emphasizes the key differentiator: 'WITHOUT loading the graph into context.'

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

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

Explicitly instructs to use 'template_slots' first for overrides, and after execution to call 'get_result' then 'get_image' (with a caveat about interpreting results). Also recommends confirming node/model existence with 'find_missing_nodes', and notes the limitation with subgraph templates. Provides clear when-to-use and when-not-to-use guidance.

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

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

No annotations provided, so description carries full burden. It discloses verification via round-trip diffing, warns about silent off-by-one in widgets_values, and explains that mismatches are reported and should be fixed. Also describes save behavior comprehensively.

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

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

The description is concise (about 90 words) yet thorough. Each sentence adds value, front-loading the primary purpose and then covering verification, warnings, and save behavior 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 complexity and the presence of an output schema, the description covers all necessary behavioral details: purpose, when to call, verification mechanism, edge case warnings, and persistence. No gaps remain.

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

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

Schema coverage is 0%, but the description adds meaning: workflow is the API graph, name and save control persisting the file. It explains the role of each parameter beyond the schema, compensating for the lack of schema descriptions.

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: 'Convert an API graph to UI/litegraph format so a human can open and edit it.' It specifies the verb 'convert' and resource, and distinguishes from sibling tools by noting that the loop builds API format and this tool is for the editable format.

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

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

The description explicitly says 'Call this when the user asks for the editable workflow.' It also implies when not to use it (the loop builds API format) and explains the save behavior. Additionally, it provides guidance on handling widgets_values positional off-by-one errors.

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

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

Discloses it reads ComfyUI-Manager's model list, shows installation status, and requires the add-on; no obvious undisclosed behaviors.

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?

Front-loaded purpose, efficient but slightly lengthy; every sentence adds value.

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?

Covers purpose, usage, parameters, prerequisites, and sibling relationship; output schema exists but not described, acceptable.

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 coverage, description explains keyword filters (name/filename/base/description) and model_type with examples, compensating well.

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

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

Clearly states it searches a downloadable model catalog for models not yet installed, lists specific model types (checkpoints, LoRAs, etc.), and distinguishes from list_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?

Explicitly when to use (discover models) vs list_models (verify installation), and states prerequisite (ComfyUI-Manager).

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 transparently describes that online templates may reference missing nodes/models and that installation is not required for browsing. However, it does not explicitly confirm non-destructive behavior, though implied.

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

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

The description is well-structured with multiple focused sentences—no wasted words. It front-loads the purpose and then details the sources. Could be slightly more compact, but still efficient.

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

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

Given that an output schema exists (not shown), the description fully covers tool behavior, parameter semantics, usage guidance, and limitations. It is complete for a search tool with two simple parameters.

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%, but the description fully compensates by explaining the 'source' parameter options (online vs installed) and their meaning, and that 'keyword' matches against name+title+description. This adds 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 explicitly states it searches workflow templates from two distinct sources, with a clear verb ('search') and resource. It also distinguishes itself from sibling 'get_template' by positioning it as a follow-up step.

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

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

Provides explicit guidance on when to use each source: 'online' for the official catalog (browsed without installation) and 'installed' for guaranteed runnable templates. Advises to fetch with get_template and reconcile against object_info for online templates.

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

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

No annotations provided, so description fully compensates. Details both success (returns prompt_id) and failure (node_errors) outcomes. Explains that zero errors means graph is VALID but not CORRECT, requiring pixel inspection.

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?

Description is front-loaded with purpose, uses bullet-like structure for failure handling. Every sentence adds value; no filler. Efficiently conveys complex information in a compact form.

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?

Completely covers usage context within a workflow system, referencing necessary post-execution steps and sibling tools. Output schema exists, so return values need not be described. All essential behavioral aspects are addressed.

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 has 0% description coverage; description adds critical meaning for 'workflow' parameter (flat API dict format). 'client_id' is not elaborated but has a default. Description greatly enhances understanding of the primary parameter.

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

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

Clearly states the tool queues an API-format workflow for execution (loop step 2: RUN). Specifies the input format as flat API/prompt-format dict, distinguishing it from litegraph/UI format. Action and resource are explicit.

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

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

Provides explicit guidance: on success call get_result/get_image, on failure read node_errors and fix specific node. Also warns against passing wrong format. Clearly differentiates from sibling tools.

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

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

No annotations provided; description fully carries behavioral disclosure. 'Report' implies read-only, no side effects mentioned. Transparent enough for a monitoring tool.

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

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

Single sentence, front-loaded, no wasted words. Highly concise and 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?

Has output schema (unknown richness). Description covers purpose and usage scenarios completely for a simple stat reporter. Could add more detail on output format but not necessary.

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

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

No parameters; description adds no param info beyond schema, but baseline for 0 params is 4. Schema coverage is 100%, so no 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?

Clearly states it reports device/VRAM usage, provides specific use cases (tuning resolution/batch, after OOM). Distinguishes from 30+ sibling tools as the only system stats reporter.

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

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

Explicitly mentions when to use (tuning, after OOM), giving clear context. No explicit when-not-to-use or alternatives, but context is sufficient for the tool's scope.

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 full burden. It discloses conversion to API format, reports literal inputs and current values, and identifies limitations for subgraph/unknown nodes. However, it does not mention potential side effects, authentication needs, or rate limits, missing some behavioral context.

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

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

The description is three sentences, front-loaded with the primary purpose. Each sentence adds value: first sentence states core function, second explains process, third details boundaries. No redundancy or 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?

While the description explains output and limitations well, it completely omits parameter semantics. Given zero schema coverage, this omission makes the tool's input interface opaque. An output schema exists (not provided), so return values are not required, but parameter documentation 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?

Schema coverage is 0% and the description fails to explain any of the three parameters ('name', 'pack', 'source'). The description focuses entirely on output behavior, leaving parameter meaning undefined. This is a critical gap for agent invocation.

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 begins with a clear verb ('List') and resource ('a template's overridable inputs'), immediately stating the tool's core function. It distinguishes itself from siblings like 'get_template' by emphasizing it avoids loading full graph JSON, and explicitly links to 'run_template' for subsequent parameter changes.

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

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

The description explicitly tells when to use this tool ('without loading the full graph JSON', 'far smaller than the raw graph') and when not to use it ('Subgraph/unknown nodes can't be expanded', 'their inputs aren't overridable this way'). It also names the sibling 'run_template' as the next step, providing clear contextual 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 full burden. It reveals the upload destination and return value, but lacks details on overwrite behavior (default true) and any limitations. Still reasonably transparent for a simple file upload.

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?

Very concise: two sentences with a parenthetical note. Front-loaded with purpose, no unnecessary words. Every sentence adds value.

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 low param coverage and no output schema details, the description covers the core use case but misses parameter explanations. It is adequate but not thorough.

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 explain parameters. It implies 'path' is the local file path but does not explicitly define either parameter, especially 'overwrite'. This is insufficient.

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 'Upload' and the resource 'local image into ComfyUI's input/ dir', and specifies the purpose: so a LoadImage node can use it. It also mentions the return value, making it distinct from sibling tools like 'get_image' or 'install_model'.

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

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

The description explicitly tells when to use this tool (for LoadImage node) and when not to (for VHS_LoadVideo* nodes, which read files placed directly in the directory). This provides clear context and alternatives.

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