← Spiral Where it started

The first design

Version one: a film as a typed dependency graph, edits that cascade in three modes, locks that keep it one film, and a converge step before anything is paid for. What it taught, and where it hit the wall.


node story
edit here scene
node shot
node frame
cascade ↓
  • auto-propagatetext-only, free
  • flag for reviewyou decide
  • hard-invalidateregenerate
locks style · character · motif · voice — injected into every prompt downstream, so the film stays one film
converge gathers what's unresolved, works out the consequences, walks you through settling them. Then, and only then, paid generation.
Every lock and cascade began as a consistency problem or a runaway edit on the two films, made by hand. Still a design, not a product.

Spiral’s first version was a design for one agent. It was distilled from making two short films by hand, and every mechanism in it began as a consistency problem or a runaway edit on thisness or Samudra Manthan.

What it was

Most AI video tools assume filmmaking is linear: prompt in, video out. Real work is revision, where every change ripples into everything downstream. So the film was modelled as a typed dependency graph (story, scene, shot, frame) and an edit anywhere moved through it in one of three cascade modes: auto-propagate for text-only consequences, which are free; flag for review where the human should decide; hard-invalidate where something must be regenerated. A converge step gathered the unresolved changes, worked out their consequences, and walked you through settling them. Only then was anything paid for.

Locks were the other half: style, character, motif and voice, injected into every prompt downstream so the film stayed one film instead of being re-prompted into coherence each time.

The decisions

  • Show the system’s reasoning at each step. The director stays the director.
  • Consistency as a primitive (locks), not something you re-prompt for.
  • A hard line between free iteration and paid generation.

All three survive in the council unchanged. The second became the lock table; the third became the render sheet, where nothing renders inside the system and the budget is the number of times you clicked accept.

What it took

Seven prototype iterations in plain HTML, CSS and JavaScript before the mechanics felt right. The evidence numbers from that era: three cascade modes, four kinds of lock, seven iterations, two films it grew out of.

The wall

One context window cannot hold a director’s taste, a cinematographer’s eye for what a video model can actually generate, and a sound designer’s argument about whose clock the film runs on. A single agent revising a graph makes every one of those calls with the same voice, and the graph tells it what to revisit but not what to disagree with. Real crews split the work up and then argue.

So the graph became a rule. In the council, each department knows which locks bind it, and a gate cannot close until every department has evaluated the current version of every one of them. The cascade is now staleness: a change does not propagate, it makes a department stale, and the stale department is woken as a critic to re-read and, if it must, to disagree. The converge step became the Director’s rulings and the round cap. The open question this version left, turning a single-user design into a multi-user system, is still open.