Protoface Reuse Result Asset

Three nodes, one file input, one reference_out. That's the entire node. It's also the difference between a two-model chain that costs you two uploads and one that costs you exactly one - which matters more than it sounds once the media is a 12-second video.

The problem it solves

Everything in the Protoface pack is a remote call. When you hand a media input a native ComfyUI IMAGE, VIDEO or AUDIO tensor, the pack has to encode that tensor and upload it before the job can start. That's fine for the first node in a chain. By the third node, you have re-encoded and re-uploaded the same 1080p frame or the same clip for the third time, and you've paid that latency for nothing.

Protoface ResultReference fixes it by not carrying media at all. Give it a prior node's files output and it hands downstream nodes a handle - the asset id of something already sitting on Protoface's side - instead of bytes for re-upload. The README's phrasing is exactly this: "Reuse result assets to chain remote jobs without reuploading their media."

The example workflow that ships with the pack is the canonical shape: Qwen Image generates a still, Reuse Result Asset hands it to MiniMax H3 as the first frame, and nothing gets uploaded twice. Two providers, one account, one asset.

How it works

The file input is typed PROTOFACE_FILE, which is what every generation node's files output carries. That object holds a local path, a modality, a content type, and - crucially - the asset_id the API assigned when the job finished. This node reads that id and emits a PROTOFACE_REFERENCE value: an asset id plus a modality, nothing more.

On the receiving end, the pack's media inputs are dynamic combos with modes. Besides Image / Video / Audio (native tensors) there's a References mode, and that's the only mode that accepts this socket. So the wiring is two-part: files → Reuse Result Asset → destination input, and destination input switched from Image to References. If you skip the second part, ComfyUI won't offer the connection, which is at least a clear failure.

There's a hard limit in the source, and it's the thing to internalise: the node refuses unless the artifact has an asset id and its modality is image, video, or audio. Hand it an SVG, a GLB, or a transcript and you get "This result cannot be reused as a media reference." Sensible - those aren't things you can feed a reference slot.

Which inputs and outputs you use

file (required, PROTOFACE_FILE): wire a generation node's files output here. Since files is a list, a node that returns several assets will feed this one per item, so a batch of four stills becomes four references - which is what you want when a model takes multiple reference images.

reference_out (PROTOFACE_REFERENCE, single): the handle. On the destination node, set the relevant input's mode to References and connect. For list-style reference inputs the pack grows item_1, item_2, … sockets as you connect, and each individual item counts toward that model's reference limit.

Worth knowing: the pack also ships a sibling node, Protoface Asset Reference, for the case where the asset didn't come from a node in this graph - you paste an existing asset id or public URL straight in. Same destination mode, different source. If you already have the media hosted, that's the shorter path; this node is for results that were just generated.

Install

Manager → search Protoface → install protoface-nodes → restart and reload the browser. Or:

cd ComfyUI/custom_nodes
git clone --branch v0.1.0 --depth 1 https://github.com/protoface-ai/protoface-comfyui.git protoface
python -m pip install -r protoface/requirements.txt

ComfyUI 0.41.0+ and Python 3.10+. Then click Protoface in the lower-right corner and paste an API key; headless boxes use PROTOFACE_API_KEY or PROTOFACE_API_KEY_FILE. It's an extension, not a model pack - no weights, no VRAM, and its four dependencies are httpx, jsonschema, Pillow, av.

Where this bites

Bypassing the node breaks the chain. This is pure plumbing, so it's tempting to think it's optional. It isn't: remove it and the destination loses its reference, which usually means the model quietly generates without the guidance you designed around. Same story as any plumbing node - the wire is the contract, per the KB's node-plumbing layer doc.

Deleting the cache deletes the handle. The asset id is recorded locally in PROTOFACE_STATE_DIR (~/.cache/protoface-comfyui by default) alongside the downloaded copy. Wipe that directory to "clean up" and re-running the chain re-uploads or, worse, asks for an asset the account can no longer resolve. Preserve it.

Asset ids are per-account. The pack namespaces its journal by credentials, so rotating your API key changes the namespace. Existing jobs come back through Protoface Resume Run; reusing an old reference in a fresh graph on a new key is the case that surprises people.

And the general one: a reference is a pointer to something on a server, so if the provider expires the asset, the chain breaks at the destination node, not here. Keep files saved locally - Protoface Save File writes the originals to output/ - if the output is worth keeping.