Quinn's Conveyance — Paid ComfyUI Knowledge MCP

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

With no annotations, the description carries the full burden and delivers important operational context: the return contents (failed approach, what was tested, what to do instead), the coverage scope, and a non-obvious cost of $0.005 per call paid in USDC on Base via x402. It omits idempotency/rate-limit behavior, keeping it just short of a 5.

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?

Four compact sentences, each earning its place: purpose, return shape, when-to-use, coverage, and pricing. The most decision-relevant info (what it does and when to call it) is front-loaded.

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

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

There is no output schema, yet the description explains exactly what comes back (failed approach, what was tested, the recommended alternative), plus coverage domains and the payment model. Nothing an agent needs to decide or call correctly 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 100% and the single 'query' parameter is documented in the schema itself. The description adds framing ('your error message, question, or topic' is not restated), so this is the baseline 3 where structured data does the heavy lifting.

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 (check) and resource (dead end for a ComfyUI video approach) with the domain of coverage enumerated (WanVideoWrapper, chaining, interpolation, upscaling). An agent can distinguish this registry-lookup tool from siblings like diagnose_comfyui_ops and get_chaining_rule without reading any 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?

Explicitly says 'Use BEFORE running an experiment you're unsure about,' giving a clear triggering context. However it names no alternatives or exclusions, so the agent must infer when diagnose_comfyui_ops would be the better pick instead.

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 behavioral burden. It adds important transactional context (cost, payment rail) and names restart/port-conflict repair actions, but it does not disclose side effects such as whether restarts are disruptive, what permissions are needed, or how the fix is applied. This is useful context but not a complete safety/behavior profile.

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 tight sentences: the first says what it does, the second says when to use it, the third adds the exclusion and cost. Every sentence earns its place, and the most important routing information is front-loaded.

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

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

Given the tool's complexity and the lack of annotations and output schema, the description covers purpose, usage, exclusions, and cost well. It does not describe what the tool returns or what diagnostics/actions the agent should expect, which is a minor gap for a fix-oriented tool with no output schema.

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 one parameter with 100% schema description coverage, so the schema already documents the query field. The description adds no syntax or format guidance beyond that, which matches the baseline of 3 when schema coverage is high and the description does not compensate with extra meaning.

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

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

The description uses a specific verb and resource: 'Fix ComfyUI operations issues on a remote Linux/DGX Spark host,' then enumerates concrete sub-areas (process detection, restarts, port conflicts, SSH quirks). It also explicitly distinguishes itself from the sibling fix_comfyui_api_prompt_error, so an agent can select it without ambiguity.

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

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

It states exactly when to use the tool ('ComfyUI is down, wedged, duplicated, or unreachable') and when not to use it ('Do NOT use for workflow/node errors — that's fix_comfyui_api_prompt_error'). This is explicit routing with both positive and negative conditions and a named alternative.

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 behavioral burden. It discloses the diagnostic/repair output, the scope limitation, and the per-call cost/payment mechanism (USDC on Base via x402), though it does not detail authentication beyond payment or any 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 front-loaded with the core action, followed by precise usage and exclusion guidance, then payment context. Every sentence earns its place and there is no redundant 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?

There is no output schema or annotations, so the description must cover behavior, usage, and output expectations. It states that a corrected JSON fix is returned and covers when to use it, but it does not describe the return structure or payment/authentication flow in detail.

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 one parameter with 100% schema description coverage, so the schema already documents the query field. The description does not add format, syntax, or validation detail beyond the schema, making the baseline score of 3 appropriate.

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

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

The description states a specific verb and resource: diagnose a ComfyUI API-prompt execution error and return a verified fix with corrected JSON. It clearly carves out API prompts versus drag-and-drop UI workflows, but it does not explicitly distinguish itself from the sibling tool diagnose_comfyui_ops.

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 gives explicit when-to-use conditions: API workflow failures at queue time with missing/invalid input errors or node type mismatches. It also gives a clear when-not-to-use exclusion: drag-and-drop UI workflow issues, API prompts only.

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, and it delivers unusually valuable operational context: the exact cost ($0.005/call), the payment rail (USDC on Base via x402). 'Get' implies a non-mutating read. It still omits return format and latency, so it is strong but not exhaustive.

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 filler, with purpose and scope front-loaded and the cost caveat placed last. Slightly dense parenthetical product naming, but 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?

Covers scope, triggering context, and payment requirement for a one-parameter lookup with no output schema and no annotations. The main gap is that it never describes what a 'recipe' looks like on return, which matters since there is no output schema to fall back 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?

Schema description coverage is 100% for the single 'query' parameter, so the schema already documents it and the baseline is 3. The description adds no syntax, format, or example guidance for the query field, so no credit above baseline.

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

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

States a specific verb ('Get') and resource ('verified pipeline recipes') and enumerates the covered domains (long-form TTS audiobook, lip-sync) with named implementations. It is clearly distinct from the ComfyUI-debugging siblings, though it does not name any sibling explicitly, which is the only thing keeping it from a 5.

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?

'Use when producing narrated audio or syncing dialogue to video' gives a concrete triggering context. There is no exclusion guidance or named alternative for adjacent cases (e.g. the error-diagnosis siblings), so it stops short of a 5.

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

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

No annotations are provided, so the description carries the full burden. It discloses a meaningful behavioral trait beyond the schema: the $0.005 per-call cost and the USDC-on-Base/x402 payment path, which an agent must know before invoking repeatedly. It does not describe the shape of the returned rule text, leaving that gap open.

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?

Four short sentences, front-loaded with the capability and its covered topics before usage guidance and the cost note. Every sentence carries distinct information with 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?

For a one-parameter lookup tool with no output schema, the description states what it retrieves, the domains it covers, when to use it, when not to, and the invocation cost. There is no output schema, so return-value explanation is not required; nothing critical 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 100% and there is a single 'query' parameter, so the schema already documents it ('Your error message, question, or topic'). The description adds no syntax, format, or constraint detail for that parameter, 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 ('Get the verified rules for chaining AI video clips') and enumerates the covered sub-topics (true-last-frame chaining, crossfade vs hard cut, pace continuity). An agent can immediately distinguish it from the diagnostic/recipe siblings.

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 an explicit positive trigger ('Use when assembling multi-clip sequences') and an explicit exclusion ('Do NOT use for single-clip generation'), which is a strong when/when-not pair. It does not name a concrete alternative sibling for the single-clip case, so it falls just short of a 5.

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

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

No annotations are provided, so the description carries the full load: it discloses that the call is free and that it is a first-step discovery action, which is useful behavioral context. However, it says nothing about the shape or size of the listing returned, and with no output schema the agent has to infer the return format.

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

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

Two short sentences, zero waste, with the core purpose front-loaded and the usage hint second. Nothing redundant.

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-param discovery tool with no output schema, the description adequately conveys what the call returns (tools and snippet IDs) and when to call it. It could be improved by hinting at the format of the returned listing, but nothing essential for correct invocation 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?

The tool takes zero parameters, so per the baseline rubric a 4 applies. The description mentions "snippet IDs" as part of the output, which frames what the (parameterless) listing yields, but there are no parameters to document.

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) and resource (paid knowledge tools and snippet IDs), so the agent knows this is a discovery/enumeration tool. It is clearly distinct from the sibling tools (diagnostics, recipes, ping), though it does not explicitly name any of 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?

"call this first to see what's covered" gives a clear when-to-use directive as an entry point, and "Free" signals there is no cost penalty for invoking it. No exclusions or named alternatives are given, but none are obviously needed for a zero-param discovery tool.

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 full burden. It does disclose one useful behavioral trait, that the call is free (no cost/billing implication), but says nothing about latency, authentication requirements, or what a healthy vs unhealthy result looks like.

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 words, front-loaded with the function before the cost qualifier. Nothing is wasted and nothing is buried.

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-param health check the definition is nearly sufficient, but with no output schema present the description could state what it returns (e.g., a status/pong) so an agent knows how to interpret the result.

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

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

The tool takes zero parameters and the schema is empty, so there is nothing to document; baseline 4 applies. The description correctly adds no param noise.

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 function: a health check, which is clearer than the bare name 'ping'. It does not differentiate itself from sibling diagnostics such as check_dead_end or diagnose_comfyui_ops, but the purpose is unmistakable for a zero-parameter tool.

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 word 'Free' implies this is the no-cost, low-stakes check to reach for first, which is an implicit usage cue. However, there is no explicit when-to-use statement and no comparison to the other diagnostic siblings.

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