Every render, with the recipe that made it.

Render 50 takes overnight. One is right. Which seed made it? Which LoRA strength, which prompt edit at 2am? ComfyUI does not say. VideoHelperSuite embeds the workflow inside the MP4 container, which is better than nothing and impossible to grep. Everything else about the take is gone at save time.

Today we shipped the fix. Dailies Take Recorder is a ComfyUI node, on the official registry as of this morning, that writes a take.json beside every video the graph renders: content hash, seeds, model and LoRA files, the positive prompt, the resolved graph, and the runtime it rendered on. Plain JSON, next to the file. It is the recording half of dailies, the open-source triage CLI we released this month. The two share one format, so a take recorded by the node can be reviewed, ranked, and labeled by the CLI with no conversion step.

What lands beside the clip

{
  "take_id": "sha256:3f9c81...",
  "shot": "shot-07",
  "parent": null,
  "created": "2026-08-26T07:14:00Z",
  "output": { "file": "take-031.mp4", "fps": 24, "frames": 121, "width": 1280, "height": 720 },
  "recipe": {
    "workflow": { "...": "the resolved graph, verbatim" },
    "models": [ { "file": "wan2.2_t2v_14b_fp8.safetensors", "sha256": null, "loader": "UNETLoader" } ],
    "loras": [ { "file": "myrna_v3.safetensors", "sha256": null, "strength": 0.85 } ],
    "conditioning": [ { "role": "LoadImage", "file": "ref_myrna.png", "sha256": null } ],
    "seeds": { "6": 424242 },
    "prompt_text": "a woman lifts a cup, warm kitchen light",
    "env": { "comfyui": "0.8.32", "torch": "2.9.1", "gpu": "Apple MPS" }
  },
  "review": null
}

4 details decide whether a record like this is useful a month later. The identity is the content. take_id hashes the video file, so a rename survives and a regeneration does not; reviews cache on it. Seeds are keyed by node id, because a graph with two samplers has two seeds and both matter. Models are found by file extension, seeds by input name, the prompt by following positive links back to a text encoder, not by node class name, so a loader released next week works without a code change. And review is null until a reviewer writes it: the node touches its own block and leaves every other block alone, including verdicts and human labels.

Before you start

• A current ComfyUI. The desktop app counts. The node uses two inputs every ComfyUI exposes to custom nodes, the resolved prompt and the workflow, and nothing newer.
• A video save node. VideoHelperSuite's Video Combine is the easy path; the core Save Video node works with one typed path.
• Optional: ffprobe on PATH. Fills fps, frames, width, and height when no VHS video info is connected. brew install ffmpeg on a Mac, sudo apt install ffmpeg on Linux.

Step 1: install it

In ComfyUI Manager, search dailies, install, restart. Or by hand:

cd ComfyUI/custom_nodes
git clone https://github.com/zhang-liz/comfyui-dailies
pip install -r comfyui-dailies/requirements.txt

The desktop app has its own Python. Use it for the pip step, or the import fails at startup: on a Mac it is ~/Documents/ComfyUI/.venv/bin/python3 -m pip. Restart ComfyUI. Double-click the canvas, type Dailies, and the node is there.

Step 2: wire it

Put Dailies: Write take.json after the node that saves the video and give it the clip, one of two ways:

• Connect filenames from Video Combine. VHS lists the preview PNG first and the video last; the node takes the video.
• Or type video_path, relative to the output folder, such as video/ComfyUI_00001_.mp4. This is the route for the core Save Video node, which has no output socket.

Queue the prompt. The node runs after the save, so the clip is on disk when the hash is taken. take-031.mp4.take.json appears beside take-031.mp4. The node's own output, sidecar_path, is a string you can feed to anything downstream.

Step 3: read it without opening ComfyUI

The point of a sidecar is that every tool already on your machine reads it. Which takes used the character LoRA:

$ grep -l myrna_v3 output/*.take.json
output/take-012.mp4.take.json
output/take-031.mp4.take.json

The seed and prompt behind the one you kept:

$ jq '{seeds: .recipe.seeds, prompt: .recipe.prompt_text}' output/take-031.mp4.take.json
{
  "seeds": { "6": 424242 },
  "prompt": "a woman lifts a cup, warm kitchen light"
}

To reproduce it, drop recipe.workflow into the ComfyUI API endpoint, or open the original MP4 in ComfyUI if VHS embedded the UI graph. Both routes now start from a record that says exactly what changed between take 12 and take 31, which is the question the morning after actually asks.

Step 4: triage the folder

The CLI reads the same file and adds the half the node leaves empty:

$ pip install video-dailies
$ dailies review ~/ComfyUI/output --shot shot-07
reviewed 40 takes, killed 23
  kill  #31  take-014.mp4   frozen for 3.1s of 5.0s
  review #1  take-031.mp4

Open take-031.mp4.take.json again and review is no longer null: verdict, kill reasons with timestamps, rank within the shot, and with a vision judge attached, the defects it found. Recipe and verdict, one record. dailies brief then answers the question the recipe makes answerable: not just which shots die, but which seeds, prompts, and LoRA strengths they died with. The overnight tutorial covers the judge, calibration from your own verdicts, and cost per usable take.

Step 5: rerun a take, keep the chain

When you rerun take 31 with a new seed, put its take_id in the parent input. The new sidecar points at the old one. Rerun that, and the chain grows. No database, no naming convention to remember; a week later jq .parent walks the history of any shot.

Turn on hash_models for the render you deliver. Model files get replaced in place on release day, and a filename alone will not tell you which wan2.2_t2v_14b_fp8.safetensors made the shot. The hash will.

What it does not do yet

It records. It does not judge. There is no gate in this release, and on purpose: a gate that kills takes deserves a stated false-kill rate, and that number comes from calibration against your own verdicts, which the CLI already does. The next node is that gate: judge after decode, pass and kill outputs, so expensive post-processing runs on keepers only. It will wrap an open video reward model rather than a hand-rolled prompt; the judge layer has commoditized, and the calibrated threshold is the part worth owning. A regen driver that requeues kills with new seeds under a budget cap comes after that.

Why a node, and why now

Before building, we scanned every pack in both ComfyUI catalogs, 7,507 in August, twice, two weeks apart. None writes a lineage record for video. None judges video inside the graph. Twenty generation platforms surveyed, none exports a per-take JSON. The metadata problem is universal and the slot is empty.

The timing is the open-weight surge. MiniMax H3, LTX-2.5, and Wan now run on hardware you own, inside ComfyUI, and nobody publishes yield numbers for local models: which prompts die, which seeds survive, at what rate. Every install writing sidecars is a sensor for that. And since this month the EU AI Act's disclosure rules for generated media are enforced; a record beside every clip that names the model, the prompt, and the hash is the cheapest provenance you can have when someone asks.

When something looks wrong

• The node is not in the search. Restart ComfyUI; nodes load at start. Check the console for an import error on comfyui-dailies.
• "ModuleNotFoundError: No module named 'dailies'": the pip step ran against the wrong Python. Use ComfyUI's own interpreter for pip install -r requirements.txt.
• "Dailies: connect VHS filenames or give a video_path": the node got neither. Connect the socket or type the path.
• fps and frames are null: install ffprobe, or connect video_info.
• Seeds are empty: the graph has no sampler with a seed or noise_seed input, which is normal for a test chain like Load Image to Create Video.

The code is on GitHub under MIT, the listing is on the registry, and the format is one short spec. Issues are welcome, especially the save node you use that we did not think of.