RunComfy MCP

Official

Overview Schema Source Related Servers Discussions Admin

get_request_result

Read-onlyIdempotent

Fetch output URLs from a completed ComfyUI deployment request. Provide the deployment ID and request ID to retrieve results stored for 7 days.

Instructions

Fetch a completed request's outputs.

Backs ``GET /prod/v1/deployments/{deployment_id}/requests/{request_id}/result``.
Output URLs are hosted for 7 days.

This is for ``submit_request`` requests on a deployment. Model API
requests from ``run_model`` use ``get_model_request_result``.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "deployment_id": "<deployment_id>",
      "request_id": "<request_id>"
    },
    "name": "get_request_result"
  }
}

Input Schema

Name	Required	Description	Default
`request_id`	Yes
`deployment_id`	Yes

Schema Changelog

Changes observed during successful MCP inspections.

First observedv1.1.0Sep 7, 2026

TDQS

A4.4/5.0

Behavior4/5

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

Annotations already declare readOnlyHint=true and idempotentHint=true, and the description adds meaningful behavioral context beyond that: it documents the backing REST endpoint and the 7-day hosting window for output URLs. There is no contradiction with the annotations.

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

Conciseness5/5

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

The description is three short sentences, each earning its place: the main purpose is front-loaded, then the endpoint, then the retention policy and routing distinction. There is no filler or redundancy.

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

Completeness4/5

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

For a simple read tool with two straightforward path parameters and all safety annotations present, the description covers purpose, endpoint, result lifetime, and sibling routing. It does not specify the exact response structure, but the 'output URLs' mention gives an agent a usable expectation of what the result contains.

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

Parameters3/5

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

Schema description coverage is 0%, but the endpoint line embeds both parameters as path placeholders, which helps an agent infer that deployment_id and request_id are required path identifiers. The description only implicitly connects request_id to submit_request and does not explain how to obtain the IDs or any format constraints, so it partially compensates for the missing schema documentation.

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

Purpose5/5

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

The description opens with a specific verb and resource: 'Fetch a completed request's outputs.' It also names the sibling tool for model API requests, get_model_request_result, so an agent can distinguish between the two request-result tools without opening their schemas.

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

Usage Guidelines5/5

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

The description explicitly scopes this tool to submit_request requests on a deployment and states that run_model requests should use get_model_request_result instead. This gives the agent both a clear when-to-use and when-not-to-use signal.

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