← Spiral How it works

The log is the film

There is no database. Every change is an appended event with an actor, a cause and a cost; every screen is a projection; and the film can be replayed to any moment.


one event
id
evt_m1x…
at
10:42:18
gate · round
ideation · 3
actor
camera · critic · model · camera@v2
caused_by
evt_m1w… (artifact.committed)
type
flag.raised
target
script an artifact, never a department
against
spine@v1
payload
severity · reason · suggested
cost
1.8k in · 0.4k out · $0.011 · 6.2s
why? · walk the chain back
  1. gate.opened you “a 10-second clip of high fashion in the slums of India”
  2. ask.answered you shoot treatment B: the fitting
  3. lock.changed director vision → v1 · spine → image_led
  4. dept.woke story writing the beats · bundle recorded
  5. artifact.committed story script v1 · the turn is in beat 3
  6. flag.raised camera on script, against spine · revise: beat 2 needs hands
  7. ruling.issued director uphold · Story keeps the hands off screen
  8. artifact.committed story script v2 · resolves the flag
projections · rebuilt from the log
  • board
  • margins
  • call sheet
  • render sheet
  • dailies
  • ledger
  • inspector
If one is ever wrong, delete it and replay. Drag the scrubber and every screen shows the project as it stood after event N.
There is no database. Every change is an appended event with an actor, a cause and a cost, so “why did this happen?” is a query, and “what did it see when it decided?” is the bundle stored on the wake.

Transparency is not a feature you add to an agent system; it is a property of how state is stored. If the only way anything changes is by appending a typed, attributed, causally linked event to a log that is never edited, then “why did this happen?” is a query, “what did the system see when it decided?” is a query, and “what would have happened if I had answered differently?” is a replay. Nothing needs reconstructing after the fact because nothing was discarded.

The event

Everything in the system is one of these. If it cannot be expressed as an event, it did not happen. An event has an id, a timestamp, the gate and round it belongs to, an actor (department, role, model, skill version), the id of the event that caused it, a type, a target (an artifact, never a department), the lock it is measured against, a payload, and a cost.

The families: gate.opened · round.advanced · gate.closed · dept.woke · artifact.proposed · artifact.committed · lock.changed · flag.raised · flag.resolved · ruling.issued · revision.requested · ask.opened · ask.answered · guess.taken · guess.reviewed · offer.made · offer.tried · offer.dismissed · asset.rendered · asset.rejected · asset.skipped · parts.waived · activity.completed · activity.failed · tool.denied · note.recorded · dailies.recorded.

A wake that does nothing still leaves a trace. A denied tool call is an event. A failed model call is an event with the error in it, and the board’s recovery buttons are computed from those.

Projections

The frontend never reads the log directly. It reads projections: the current version of every artifact with its version history, the lock table, open flags, open asks, pending offers, unreviewed guesses, each department’s last-seen lock versions, gate status, the render sheet and which of its items have a take accepted, what is still unwritten at this gate, the cost ledger, the failures. All of it is one function over the array of events. If a projection is ever wrong, delete it and replay.

Three things that fall out for free

Why. Every event carries the id of the event that caused it. Click any line on the board and the Inspector walks the chain back: this shot list entry was revised because of this ruling, which answered this flag, which was raised when this script version landed, which was written because you chose treatment B. On the wake event the assembler stored the bundle, part by part, so the question “what did it have in front of it?” is answered on the same screen.

Time travel. The Inspector has a scrubber from zero to the number of events. Drag it and every screen is rebuilt from the first N events: the board, the margins, the call sheet, the convergence table, as they stood at that moment. Nothing is simulated; the projection function just gets a shorter array.

The ledger. Every model call records input tokens, output tokens, elapsed time and an estimated cost, attributed to a department and a role. “What did Sound cost this film?” is a sum. So is “how much did the round cap cost?”, and “what did the critic’s revisions cost against what they caught?”

The dailies

At every gate close the Producer’s recorder reads the gate’s events and writes a digest a filmmaker can read in two minutes: what changed, what was argued, what was ruled, what was guessed on your behalf, what was offered and not yet tried, what the council noticed that nobody asked about, and the roads not taken. Departments that did not wake during the round read the dailies at the next gate instead of the log. So do you.

Export, import, fork

The log is the project. Export it and the whole film goes with it as one JSON file; paste it back and everything reappears. The design’s fork (branch the project at any event, answer differently, let the council run) is a copy of the log up to that event, and the prototype’s import button is most of the way there.