seam

Two shots in. One transition out.

Drop two images, two clips or two 3D models. Pick an effect. An open-weights video model renders the in-between on your own GPU, through ComfyUI. Every take is a ComfyUI workflow you can open.

▶ Watch the 2-minute demo · Project site · Install

Seam is an open-source take on the "transitions" apps (Higgsfield, Kling, Pika), built for Comfy's
Open Source Higgsfield challenge. No accounts, no credits: the
model runs on your machine and every take can be reopened, inspected and re-run in ComfyUI.

• Web studio: shots on the left, the take on the right, your gallery below. Images, 1–6 s clips or 3D models
  as input, ten qualified effects (5 s takes, 10 s for Smoke, Water bend and Whip pan) or Surprise me, and three examples so you can try it in one click.
• Sequences: more than two shots? Put them in order, pick an effect per hand-off, and Seam renders each
  transition and joins them into one video (clips play in full at their place). A bad hand-off gets a new take on
  its own; the others are reused. Or grow a story shot by shot: Continue a finished two-shot take with a new
  shot, then keep adding; only the new transition renders, and every transition starts from your own shot, so the
  story stays as consistent as the shots you bring.
• CLI: seam make first.png last.png --preset smoke, seam sequence make 1.png 2.png 3.png --preset smoke,whip_pan, then seam sequence extend <id> 4.png --preset ink, and seam sequence edit <id> --order 1,3,2,4 --transition 1=ink --transition 2=melt --transition 3=smoke to reorder (only the new hand-offs render).
• Agent plugin: a skill + MCP server so Claude Code (or any MCP agent) can plan, render, review and refine
  transitions for you. Packaged as a Claude Code plugin and as an Agent Plugins 1.0 plugin.

Why it's different

Tour

Try an example or drop your own shots. The Effect node plays each effect's preview on hover.	3D model in. Frame the .glb, then Record orbit (3 s, 120°) or keep one angle as a still.
Make transition. The graph's wires carry the take into Output while LTX-2.5 renders (~45 s on an RTX 5090).	The take. With clips or transition only, open the exact workflow in ComfyUI, make a new take, download.

The studio is styled after comfy.org: Comfy ink and yellow, condensed type, and ComfyUI's own node-and-wire
language (socket colours by type). Design notes: DESIGN.md.

Takes

All real renders, seed 1, no retouching. The input stills are fictional and were generated for testing.

A person (first shot → Seam → last shot)

First shot	Smoke	Water bend	Whip pan	Last shot

A product (sneaker on wet concrete → cup on a mossy rock)

Smoke	Water bend	Whip pan

3D models — the egg and the brachiosaurus at the top of this page: two .glb files, two recorded orbits, one take.

Measured (RTX 5090 32 GB, Windows 11, ComfyUI Desktop 0.41.3; 5 s clips at 1280×704 or 704×1280):

Render time runs from submit to finished video, including LTX-2.5's prompt enhancer and any model loading (the
slowest takes were the first after a load). Reading the two shots (~1 s each, cached) comes on top. Peak VRAM was
~31 GB on a 32 GB card; 24 GB cards should work through ComfyUI's offloading (64 GB RAM) but are untested.
The qualification record is dev/PRESET_REVIEW.md.

3D models in

Drop a .glb on either shot. Seam opens it in a small 3D studio in the browser (three.js): neutral set, studio
light, the model framed for you; drag to change the angle.

• Record orbit renders a 3 s, 120° camera orbit and uploads it as a clip. The transition leaves from where the
  first orbit ends and lands where the second orbit begins, and Seam joins orbit + transition + orbit into one
  video. The orbit is paced by the clock, so a slow GPU drops frames but the clip still lasts 3 s.
• Use this angle keeps one view as a still.

The model never leaves your machine; only the recorded orbit or still goes to the Seam server, like any upload.

Hackathon submission

Quick start

You need an NVIDIA GPU with 32 GB (24 GB untested), 64 GB RAM, ComfyUI ≥ 0.41.3, Python 3.12 with uv, Node 20+
and ffmpeg. The full guide, written so an agent can follow it too, is install.md.

git clone https://github.com/jdnichollsc/seam && cd seam
uv run python scripts/download_models.py --models-dir "<ComfyUI>/models" --only l25   # ~44 GB, open weights

uv tool install comfy-api-proxy==0.1.6
comfy-api-proxy start --comfyui http://127.0.0.1:8188                                  # Comfy API v2 on :8189

uv run seam doctor     # checks ffmpeg, the Comfy API, nodes, models and the web build
uv run seam serve      # http://127.0.0.1:7860

Agents. In Claude Code:

claude plugin marketplace add jdnichollsc/seam
claude plugin install seam

Then ask for a transition ("make a smoke transition from a.png to b.png and show me a preview"). The MCP server
exposes seam_status, list_presets, create_transition, wait_job, preview_job, refine_job, get_job,
list_jobs and cancel_job, plus create_sequence, wait_sequence, get_sequence, preview_sequence,
refine_segment, cancel_sequence, continue_take, extend_sequence and edit_sequence (remove / reorder
shots, a story line for the whole film) for multi-shot videos; the skill tells the agent how to plan shots, judge a take and refine it.

How it works

browser / CLI / agent (MCP)
        │  REST + live events
   Seam server (FastAPI) ── presets → model-specific prompt + slot-mapped workflow
        │  Comfy SDK  (comfy-sdk, Comfy API v2)
   comfy-api-proxy  →  ComfyUI (core nodes only)  →  LTX-2.5 on your GPU

• Every generation goes through the official Comfy SDK against the Comfy API v2, served locally by
  comfy-api-proxy. No GPU? seam backend cloud renders the same graphs on your Comfy Cloud account (see install.md). A deployed endpoint works through COMFY_BASE_URL
  (neither has rendered a real take through Seam yet).
• Each effect is a preset (our own prompt text) routed to the model that renders it best: LTX-2.5 first/last-frame
  with its in-graph prompt enhancer (every launch effect), or LTX-2.3 with an open transition LoRA.
• Seam reads both shots first with the same small local model as the enhancer (Gemma-4 E2B), so the prompt says
  what is in them. You can correct that line before rendering.
• Workflows are the official ComfyUI templates exported to API format; Seam only touches them through a named
  slot map, with a test that fails if the template drifts.
• Jobs persist in SQLite and survive a server restart (they re-attach to the running ComfyUI job, and a job that was
  mid-submit is reported, never silently resubmitted).
• Clips in, clips out: either side can be a 1–6 s clip (normalized to one clock on upload). The transition starts
  from clip A's last frame and lands on clip B's first, and Seam joins clip A + transition + clip B with ffmpeg.
• Every take is reproducible: a receipt (input hashes, effect, model, seed, final prompt, graph hash) and a
  one-click Open in ComfyUI bundle: the exact API workflow plus both stills, runnable in plain ComfyUI.
• The server only answers on loopback and refuses cross-site writes.

Built with

Models and licenses

Seam's code is MIT (LICENSE). The models keep their own licenses; read them before commercial use.
The effect presets are our own text, inspired by common transition concepts — no third-party prompts or media.
The 3D models (.glb) in the demo are the author's own assets, released under MIT.

Status: tested on Windows 11 with one RTX 5090. Linux, macOS and smaller GPUs are untested.

Responsible use

Use images you own or made. Don't put a real, identifiable person into a transition without their permission.
Keep it SFW.

Credits

Built on ComfyUI, the Comfy SDK
and comfy-api-proxy, LTX by
Lightricks, and the open transition LoRA by valiantcat. Made for #OpenSourceHiggsfield
by @jdnichollsc.