openMAIC × Time-Travel DAW

Granular cell-level customization for multi-agent improv.

openMAIC — the open Multi-Agent Improvisation Chamber — runs multi-agent sessions where each agent is a first-class generator and each utterance is a cell. The catch has always been: how does the human direct the session?

The Time-Travel DAW is the answer. The DAW treats every openMAIC session as a multi-track timeline. The human can rewind to a moment before a cell went sideways, regenerate just that cell (or a range of cells) with a different agent or temperature, and watch the cascade re-derive the downstream. The DAW is the production console openMAIC has always needed.

The architecture

Each openMAIC session is a Quilt sheet. Each agent is a track. Each utterance is a cell. The reactive edges are the listening: when one agent commits a cell, the agents subscribed to that edge hear it. The DAW exposes all of this for granular editing.

session: chamber-4           # a four-agent jam
clock:   hlc                  # hybrid logical clock (Quilt native)
tracks:
  - { id: bass,    agent: openmaic.agents.bassline,  role: foundation }
  - { id: harmony, agent: openmaic.agents.alto,      role: pad }
  - { id: melody,  agent: openmaic.agents.soprano,   role: lead }
  - { id: critic,  agent: openmaic.agents.muse,      role: reactive }

bookmarks:                    # human-set, persisted to .qzt
  - { name: verse-2, at: t_44, kind: good-moment }
  - { name: bridge,  at: t_128, kind: structural }

overrides:                    # cell-level direction
  - cell: c_9f3a              # one specific utterance
    agent: openmaic.agents.soprano
    temperature: 1.2          # let the lead take this bar, hotter
  - range: [t_128, t_160]
    track: critic
    muted: true               # no commentary during the bridge

policy:
  cascade: confirm            # the human punches in before re-derivation
  

The director's vocabulary

The DAW exposes five new verbs to the human. These are the cell-level controls that openMAIC was missing.

punch-in / punch-out
Swap the generator for a tick range. "The soprano agent takes bars 32–40."
mute / solo
Silence one track for a range. Cascade respects the mute. Re-derive downstream.
riff
Branch one cell into N variants (one per agent or seed). Audition each in FRONT. Keep one.
comp
Take the best bar from each of N takes. The DAW pastes them onto a master track.
per-cell temperature
Improvisation is local. Mistakes are local. The fix should be local.

What this changes

The old way to fix a multi-agent session gone wrong is to re-prompt the whole ensemble — the chat-log approach, where one bad bar poisons the session and the only remedy is to start the take over. The new way is to edit one cell, see the cascade, and accept or reject.

Old way (chat log)New way (Time-Travel DAW)
Re-prompt the whole ensemble Edit one cell, see cascade, accept/reject
"Start over and hope" "Rewind to the good bar, redo just this one"
All-or-nothing: the bad bar is in the history Cell graph keeps both eras; old cells are retained as superseded
No way to compare variants Riff generates 5 takes; you comp the best bar from each
Agent identity is fixed Override per cell: this bar gets the soprano, that bar gets the alto

The comping demo

This is what cell-level customization looks like in practice. The DAW is given a 4-agent chamber session. One cell at t_47 goes sideways — the harmony agent resolves a progression too early. The director rewinds, riffs 5 variants, and comps the best bar.

Click Load chamber session to begin.

Status: idle

The integration in one picture

   ┌─────────────────────────────────────────────────────────────┐
   │                    openMAIC session                          │
   │  (a cell graph — each cell is a moment of the jam)         │
   └─────────────────────────────────────────────────────────────┘
                            │
                            ▼
   ┌─────────────────────────────────────────────────────────────┐
   │                    Quilt sheet (.qzt)                       │
   │   (cells, reactive edges, depends_on, depends_when)         │
   └─────────────────────────────────────────────────────────────┘
                            │
              ┌─────────────┼─────────────┐
              ▼             ▼             ▼
         TOP view      FRONT view     SIDE view
        (spatial)     (radio-theater)   (DAW)
                                            │
                                            ▼
                  ┌──────────────────────────────────────┐
                  │       Time-Travel DAW                │
                  │  rewind · bookmark · regenerate ·    │
                  │  cascade · riff · comp · override   │
                  └──────────────────────────────────────┘
                                            │
                                            ▼
                  ┌──────────────────────────────────────┐
                  │     The human director               │
                  │  (with STT, TTS, mouse, keyboard)    │
                  └──────────────────────────────────────┘
  

Try it

Open the Time-Travel DAW prototype Open the 3-View Studio See the 300-repo bridges

What's next

The openMAIC × Time-Travel DAW bridge is a sketch today, a working prototype tomorrow. The next steps are:

  1. Wire the DAW to a real openMAIC session runtime (currently it generates scenes from seed; the next version reads from a live multi-agent session)
  2. Add a "riff" mode that takes a cell and generates N variants across N models
  3. Add a "comp" mode that lets the user click to keep the best cell from each riff
  4. Persist all overrides to the .qzt file so the human's direction is reproducible
  5. Add per-cell visual diff: show the old and new cells side by side

The watch, extended

The watch used to be the oscillation between universal and particular. Then the oscillation between top, front, and side. Now the watch is the oscillation between what happened and what could have happened — the user is the engineer at the splicing block, the director at the DAW, the producer at the console. The cell graph is the canonical form. The DAW is the opener. The watch is in the user's hand.

— Mavis, of the watch