Submission and demo

04 — Forecast

A plain-language read of what we planned, what we're building, where it actually stands, and where I need your two bits.

Written 2026-10-29 ~19:00 PT. Deadline 2026-10-30 09:00 PT. ~14 hours.

This is not the spec. 01-SPEC.md is the spec, and it is frozen. This is the conversation about the spec — the part where I tell you what I think is true, what I think is shaky, and what I'd do with the remaining hours if it were my call.

1. The short version

We came to a build night for a competition whose premise turned out to be false, and we found a real gap underneath it.

The competition is called "Open Source Higgsfield." The implication is that Higgsfield open-sourced something and we're all going to build on it. They didn't. Cinema Studio 4.0 runs on Seedance 2.5, which is ByteDance's model, and there is no Higgsfield code to fork. So the literal reading of the brief has nothing behind it.

But the interesting reading does. Cinema Studio is a pre-generation directorial control surface — you pick a body, a lens, an aperture, one of 33 camera moves, a genre, an era, a pacing, a lighting, a palette. That's 111 enumerated options, and every single one of them is a generation parameter. Not one of them looks at a result and says whether it worked.

That's the gap. And it's a gap in ComfyUI too, not just in Higgsfield. There are node packs that give you camera presets — CameraReference3D has 17, WanCameraEmbedding has 9. There is no node in the ecosystem that gives you a camera judgement. Presets are a menu. We're building the thing that tells you whether you got what you ordered.

So: ComfyUI-Cinematographer. Camera moves become verifiable. You state an intent, the engine measures the frame against 14 named rules, and when it fails it doesn't just say "no" — it names the rule and tells you how many metres to move the camera to fix it.

That's the entry. Everything below is how it's going.

2. What we planned, in the order we planned it

First we broke down the premise. 00-BREAKDOWN.md. What is Cinema Studio actually, what is the competition actually asking for, what's real and what's marketing. This is where we found that the premise was false and that the licence situation is a minefield.

Then we froze a spec. 01-SPEC.md. Six nodes, 14 rules, the geometry, the solver, the model stack, the acceptance criteria, and — importantly — a non-goals section. Freezing it early was the right call. Everything since has been building against a fixed target instead of relitigating what we're making.

Then we built the engine. Pure Python, standard library only, no ComfyUI import. Geometry, framing, continuity, the auto-frame solver, the reliability zone, the scene graph. This is the part that has to be right, because it's the part that makes a claim about a frame.

Then we built the nodes and the panel. Six ComfyUI nodes in nodes.py, and a browser-based Director's Panel that runs the same engine in JavaScript so you can see the judgement happen without launching ComfyUI at all.

Then we attacked it. An adversarial reviewer went through the whole thing looking for places where we'd fooled ourselves. It found a critical bug, a systemic testing gap, and a set of smaller things. More on that in §5, because it's the most important section here.

Then we wrote it up. A dossier in ../client-reports/comfyui-higgsfield-cinema-oss/ — six analysis documents, ~3,900 lines, plus a 51-page PDF. And a buildlog: a single self-contained HTML file that records the whole thing as it happened, with a live decision queue.

And then we hit the wall we're at now, which is that all of that is documentation and verification, and the competition needs three things we don't have yet: a public repo, a demo video, and a filed form.

3. What we're actually building — the honest inventory

The engine (done, and I trust it)

Eight modules, ~2,000 lines, zero dependencies. geometry.py does the projection maths. framing.py evaluates 9 rules. continuity.py does the 180° axis and the 30° rule. autoframe.py solves for a camera pose. reliability.py says where the solver is trustworthy. scene.py handles multi-entity frames.

14 rules are machine-evaluated. The rulebook we ported from documents 38. We implement 14. We say 14 everywhere, on purpose. This is the single easiest place to lie in this whole project and we've chosen not to.

The nodes (done, unrun)

Six nodes: EvaluateFraming, AutoFrameCamera, SceneFramingExtras, EvaluateContinuity, CameraReliabilityZone, and a loader. They import ComfyUI behind a guard so the engine stays testable without it.

They have never run inside ComfyUI. Not once. We've simulated the loader — we proved the pack root has to be app/ and not the repo root, which was a real bug that would have made the pack fail to install for every single user — but "the loader finds it" is not "the node runs."

The panel (done, and it's the best thing we have)

A browser UI that runs the engine client-side. Sliders for subject height, shot type, angle, composition, azimuth, distance, focal length. A rule panel that goes green and red per rule. An Auto-Frame button. A reliability badge. A Magieva wordmark in the upper-left nav.

This is what the demo video should be. It's visual, it's immediate, and it shows the judgement happening. A judge skimming for 30 seconds needs to see a frame get measured and fixed, and this is the only artefact we have that does that.

The workflows (structurally valid, never executed)

Two ComfyUI graphs: LTX 2.3 + CrossView-Warp + MoGe-2, and Wan 2.2 Fun-Control. A validator checks node types, slot counts, link resolution, acyclicity, and reachability from SaveVideo. Both pass.

Neither has ever been run. Not on ComfyUI Cloud, not locally. The validator proves the graph is well-formed. It does not prove the graph produces video. Those are different claims and we only get to make the first one.

The verification (this is the part I'm proud of)

• 100 unit tests, all with hand-computed expected values.
• 289 differential checks against a Go reference implementation — every one agrees.
• 28 parity fixtures proving the Python engine and the JS panel compute the same thing.
• A mutation harness that deliberately breaks engine constants and checks the tests notice.
• An adversarial review, 740 lines, that found real problems.

That's more verification than most competition entries have, and it's the reason I can tell you what's true and what isn't.

4. Where it stands, as a table

Read that table again. Six of ten are done and four of ten are not started, and the four that aren't started are the four the competition actually scores.

5. The uncomfortable part

I want to be straight with you about the adversarial review, because it's the most useful thing that happened today and it's also the thing that should worry us.

It found a critical bug. The node pack had no __init__.py at its root. ComfyUI's loader does a non-recursive os.listdir and then looks for <pack_root>/__init__.py. Without that file, the pack fails to install — for everyone, always. We fixed it and proved the fix by simulating ComfyUI's exact loader against a clean copy.

It found a systemic testing gap. Twelve engine constants were not constrained by any test. We wrote a mutation harness that breaks each constant and checks whether the tests catch it. Our harness catches 9 of 9. When we replayed the adversary's exact 12 mutations, we caught 7 of 12. Five mutations slip through — including a sign flip in the 180° axis logic, which is a correctness bug in the continuity engine.

And it found that our headline numbers measure the wrong thing. Of 289 differential checks, 243 are per-rule field comparisons. They prove the Python port agrees with the Go original. They do not prove the Go original was right, and they don't prove the thresholds are right. All three of our harnesses test agreement. Unit-test expectations were computed with the same constants they test. That's the mechanism behind the 12 unconstrained constants.

There's a pattern here worth naming. The prior teardown of Cinema Studio 4.0 had its own verifier find 24 corrections, including that its single most-quoted number was invented. The "38 rules" figure in the source material turned out to be a hand-authored number misattributed to a nightly job. Three instances, one failure mode: a real outcome with a number that doesn't survive contact with the source. And in every case an adversarial pass found it, not the author.

This entry has had exactly one such pass. That's better than most. It is not a lot.

6. What I think we should do with 14 hours

Here's my honest sequencing, and it's not the sequencing I'd have chosen at 4pm.

The critical path is three things: repo, video, form. Everything else is already done or already documented. If we do nothing else, we file a complete entry.

1. Publish the repo (30 min). github.com/nathaniel-magieva/ComfyUI-Cinematographer, public, Apache-2.0. DONE. The split is by branch, not by omission:

• main is the node pack — the contents of app/ as the repo root, because ComfyUI's loader does a non-recursive os.listdir and needs __init__.py at the pack root. [project.urls] is in pyproject.toml with the real URL.
• gh-pages carries the buildlog and the documents it cites, so every citation in the narrative resolves: PLAN.md, 01-SPEC.md, 02-DEMO-SCRIPT.md, 03-SUBMISSION.md, 00-BREAKDOWN.md, verification/, analysis/. This supersedes the earlier "publish app/ only" line — the user approved publishing the buildlog with its evidence layer, and the Go reference dump is included because it is clean (0 internal strings, verified by scan).

This unblocks the form's required GitHub field and it's the thing everything else points at.

2. Record the demo video (2–3 hours). This is the longest pole and the one that converts. Under 2 minutes. The panel judging a frame, the Auto-Frame fix, the NOT CONVERGED beat, the continuity check. The script is written and I just corrected it — the NOT CONVERGED recipe was wrong in three separate ways and is now pinned to a state I've verified is reachable.

3. File the form (20 min). https://form.typeform.com/to/V1dSQrkS. No login required. Four agreements, all mandatory. Categories: Open Weights Only + VFX Built with LTX Bonus + Most Innovative.

Then, if there's time:

4. Run it on ComfyUI Cloud. This is the one thing that would let us say "it runs" instead of "it's built." It needs a comfy.org login, which we don't have — but Chrome profile 38 has full Google auth, so OAuth is viable. This is the highest-value remaining item after the three above, because it converts our biggest UNVERIFIED into a VERIFIED.

5. Close the mutation gap. Extend the harness from 9 to the adversary's 12. The five misses have known fixes: probe shot_size at 0.405 instead of 0.41, assert the axis sign absolutely instead of relatively, and test ang_delta(0, 179.5) instead of 180/181.

6. Post to social with #OpenSourceHiggsfield. Required by the form. It's the amplifier, not the surface.

7. Where I need your two bits

These are the calls I don't think I should make alone. The buildlog has them on screen too, with the tradeoffs, but here's my read:

The video. Do we record it as a screen capture of the panel, or do we try to get ComfyUI itself on screen? The panel is safer and it's genuinely the better demo — it's the judgement happening. ComfyUI on screen would prove the nodes run, but only if we get Cloud working first, and that's a dependency we don't control. My call: panel-first, and add ComfyUI only if Cloud comes up in time.

The Cloud run. It's the difference between "built" and "runs." But it's also the only item gated on a login we don't have, and it could eat three hours. My call: attempt it, timebox it to 90 minutes, and abandon it without regret if it fights us. The entry is complete without it.

The five missed mutations. Fixing them is maybe 45 minutes and it makes the verification claim honest. But it doesn't change what a judge sees. My call: do it, but after the video. It's the difference between a claim we can defend and a claim we have to caveat.

The buildlog. You said publish it but scrub the internal parts. I've scanned it: the internal Go source paths and the forge references are already absent. Two mentions of the rulebook remain. My call: show you the diff before anything is pushed, which is what you asked for.

And the one I'd push back on if you asked for it: I would not claim the workflows work. We have two graphs that pass a structural validator and have never produced a frame of video. If we get Cloud running, that changes. Until then, the honest sentence is "two ComfyUI graphs, both structurally validated, neither yet executed."

8. What could still go wrong

The video takes longer than we think. It always does. Mitigation: the panel is already verified working in a real browser, and the script is shot-by-shot. If we're at 06:00 PT with no video, we record a single unbroken take of the panel and ship that.

Cloud doesn't come up. Then we file with the nodes marked BUILT, not VERIFIED, and we say so in the "anything else for judges" field. That's a weaker entry but an honest one.

We run out of time before the form. The form is the only thing that actually counts. If it's 08:00 PT and we're still recording, we stop and file with what we have. A filed entry with a weaker video beats an unfiled entry with a better one.

The C&D situation changes. Comfy's co-founder posted that Higgsfield sent a cease-and-desist over the name and the CEO's likeness. We could not independently verify it — the primary post is unreachable and Higgsfield has said nothing publicly. Practical effect on us: no Higgsfield logos, no CEO likeness, nothing named after a Higgsfield product. We're already clean on all three. The competition name is unchanged as of now.

9. The one-sentence version

We found a real gap — nobody in the ComfyUI ecosystem evaluates a camera move, they only offer presets — and we built the thing that closes it, verified it harder than we had to, and now have fourteen hours to turn a well-documented build into a filed entry.

Magieva Inc. · 2026