Save To GenAsset

If you only add one GenAsset node to a workflow, it's this one. Save To GenAsset is the write side of the whole system: you've just generated an image you like, you drop this node on the end of the graph, and it uploads the pixels plus the full recipe that made them - prompt, negative prompt, model, seed, steps, sampler, scheduler, denoise, the workflow JSON, and a chunk of reproducibility metadata the pack calls Repro Lock.

That's the entire pitch of GenAsset in one node. The image stops being a dead file and becomes a version in a cloud workspace, so the next time you (or a teammate, or an agent) want "the one from Tuesday with the good lighting," it's loadable, comparable, and branchable. In a hobby workflow it's optional bookkeeping; in anything shared, it's the difference between a pile of PNGs and a searchable history.

How it works

This is the only node that does serious auto-capture, and it's worth knowing how much you're getting for free. When it runs, the node walks upstream through your graph (starting from the sampler it can find), pulls the checkpoint/UNet name, the seed and sampling settings, the positive and negative prompts - including prompt-bearing nodes like Qwen-based edit prompts - and grabs the ComfyUI API prompt plus workflow JSON with token-like fields redacted. If your graph has upstream LoadImage nodes and the files are in the ComfyUI input folder, it uploads those as input artifacts too.

Then it does two safety checks you'll actually appreciate. First, it refuses to save a blank or near-black frame - a failed generation doesn't become a poisoned version in your history; you get a status_json explaining the rejection instead. Second, it attaches metadata.repro_lock with environment details (ComfyUI commit, node pack versions, Python/Torch/CUDA/MPS, model hashes when files are small enough) so you can reproduce later or at least know what drifted.

The inputs and outputs that matter

Four required inputs: image, base_url, token, and asset_name. You'll set base_url to the default and let the token come from your ComfyUI/user/genasset.json file (see below). asset_name is what the asset is called in your workspace.

The optional inputs are where the real power is:

• asset_id - leave empty to create a new asset. Paste an existing asset's UUID to append a new version to it, which is how you build an edit history instead of 40 one-off assets.
• tags_csv - extra tags merged with the auto-derived ones.
• intent - a label like txt2img, img2img, or upscale.
• notes_md - asset-level notes; and version_label - a short label stored in version metadata.
• metadata_json - extra JSON merged into the captured metadata.

Outputs are an image passthrough (handy if this node isn't last in the chain), plus asset_id and version_id - the two UUIDs you'll paste into every other node in this pack - and status_json with the full server response.

Installation

From ComfyUI Manager, search GenAsset and install, or:

cd ComfyUI/custom_nodes
git clone https://github.com/steliosot/ComfyUI-GenAsset.git

Then restart. No extra pip packages needed - requirements are just what ComfyUI already ships. Before your first save, create a workspace token at genasset.xyz and put it in ComfyUI/user/genasset.json:

{ "base_url": "https://genasset.xyz", "workspace_token": "PASTE_TOKEN" }

Common issues

• "Image looks blank or black, so GenAsset did not create a version" - the black-frame guard tripped. Rerun with a different seed or more steps rather than fighting the node; it's protecting your history.
• Save "succeeds" but asset_id comes back empty - read status_json. The pack routes almost every failure through that output as a JSON error field, so it's the first place to look.
• Tokens in saved workflows - the workflow JSON is redacted before upload, but that protection only covers what the pack captures. Don't paste a token into a node widget and then export that workflow file publicly; the README is blunt about it.
• It's slower than you expect the first time - the node computes image quality metrics and hashes model files. The first save on a big model can lag while it fingerprints files; later saves reuse hashes where it can.

The one trap most people hit: this node captures a lot, but it's a cloud call. Your image and recipe leave your machine by design. If that's a problem, GenAsset isn't for you - but if your pain is "I can't find the run that made this," this node is the whole cure.