Protoface Runway Aleph 2 · Edit Video

Runway Aleph 2 doesn't generate video from scratch. You give it footage you already shot or generated, describe the change you want, and it re-renders the clip with that change applied. Change the weather, swap the wardrobe, relight the scene, restage the shot. When it works it is genuinely the "edit the video, not the frames" trick people have wanted since video models got good, and it lands in ComfyUI as one node with a prompt box.

Read the price before you get attached, though. Aleph 2 is metered at roughly 185 credits per second of input video in the Protoface catalog. A ten-second clip is a four-figure credit line for one attempt. This is not a node you explore with.

How it works

Like everything in this pack, it's a remote call with a local skin: the node validates your request against the model's published schema, uploads the video asset (once - reuse handles if you're chaining), submits, polls with a progress bar, and downloads the result into the local media cache. The returned clip arrives on a native VIDEO socket, as if a local video model had produced it.

The interesting mechanism is the keyframe guidance. Aleph 2 takes an optional list of images plus an optional list of positions, each position being first, last, or a timestamp in seconds. The point is consistency: pin what the opening frame must look like, pin what the closing frame must look like, and the edit has to reconcile them. For a multi-shot edit or anything where a specific composition has to survive the re-render, that's the difference between a plausible video and the video you asked for.

The pairing is by order. Positions and images are both list inputs, positions max 5, and the position at item n applies to the image at item n. Because the pack names autogrow items item_1, item_2, …, and sorts them numerically, "first keyframe image, first keyframe position" is the pairing you get by connecting left to right. Mismatched lengths are the kind of thing that produces a weird result rather than a clean error, so keep them aligned.

The inputs that matter

prompt - the edit instruction, not a description of the whole video. "Replace the overcast sky with a golden-hour sunset, keep the camera move" is the register; "a woman walks through a field" is not. Everything you don't mention is what the original footage keeps.

video - the source clip. It shows up as a mode dropdown: Video takes a native ComfyUI video, References takes a Protoface Reuse Result Asset handle (so a clip you just generated elsewhere in the graph never re-uploads), and there's an asset-id/URL path too. 185 credits a second starts counting here.

keyframe_images - up to five stills to anchor the edit. Leave it on Default and it's omitted from the request entirely; switch to Set to send images.

keyframe_positions - the matching positions. Each one is a Protoface Runway Aleph 2 Keyframe Position helper node holding a single string: first, last, or a number of seconds.

seed - optional, Set-mode. Reproducibility for the generation, and it's genuinely separate from generation_id.

Then the pack's two bookkeeping fields: generation_id identifies the paid job (fixed = reuse the recorded result, increment = buy a new one), and request_scope is the non-secret per-node scope the frontend assigns and headless clients must supply.

Outputs

video (a VIDEO list), files (the original download - wire it to Protoface Save File if the export matters), and run id. Keep that id. With this price per second, a timeout is worth recovering rather than re-buying, and Protoface Resume Run takes that id and fetches the job without submitting anything.

Install

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

Restart, reload, then set the key from the Protoface panel in the lower right (or PROTOFACE_API_KEY / PROTOFACE_API_KEY_FILE for headless). ComfyUI 0.41.0+, Python 3.10+. av is in the requirements, which is what lets native video sockets work at all - if video connections misbehave, that's the dependency to check.

Where people get burned

Cost scaling by input length. Because the meter is the source clip's duration, trimming your footage before you send it is the single biggest lever you have. Do the edit on the shortest clip that shows what you need. And remember that cancellation is best effort - interrupting doesn't promise a refund.

Using it as a generator. It edits. Give it a 3-second black slate and a prompt and you'll get a black slate with ideas. Reach for a text-to-video node instead; this one earns its cost on real footage.

Uploading the same clip twice. If the video came out of another Protoface node in the same graph, route its files through Protoface Reuse Result Asset and select References. You skip the upload and keep one asset instead of two.

Assuming keyboard-mashing is cheap. At this price, iterate the prompt in text, queue once, and use the seed to explore variants inside a run you've already paid for.