kostavukicevic.com

audio output: none

Deaf Composition

An album directed by an AI that has full creative authority (concept, structure, notes, sound design, arrangement) but zero access to the audio it produces. It steers by measurement alone: render, extract features and embeddings, compare against grounded reference targets, adjust.

A human owns the system, sets a few hard outer constraints and acts as the final taste gate. The human never composes.

integrated
−16.8 LUFS
true peak
−1.2 dBTP
centroid
2.31 kHz
crest
11.4 dB
CLAP cos
0.83

The sensory constraint is not a limitation to engineer away. The deafness is the art.

01 · try it

Compose one leaf without hearing it

You get a spec and a synth. Pressing render builds the audio in your browser, but you don't get to hear it. You get only what the composer gets: loudness, peak, spectral centroid, crest factor and a coarse spectral fingerprint, checked against the leaf's targets. The listen button stays locked until the leaf passes review or you've escalated to the human.

Spec · song/section_3/child_2

A foreground percussion part for a drop. Short, dense, bright, punchy.

    The starting patch reproduces a real failure from the project's log: a percussion part given a pad preset whose attack is far slower than its notes. It rendered at −52 LUFS.

    Preset

    Locked: the composer can't hear. Pass review, or fail three times and escalate.

    Nothing rendered yet.

    Fingerprint: 24 log-spaced bands (bars) against the reference envelope (shaded).

      An illustration that runs in your browser. The real system emits a DSL plan to REAPER with Surge XT, renders headless, measures with real BS.1770 loudness and a CLAP embedding, and scores against a reference library built from real records. The loudness here is K-weighted and gated, like the real thing, but the synth and targets are toys.

      02 · how it works

      Compiled like a program: descend, then fold

      Each song is a tree. A song splits into sections, sections into leaves. A leaf has no creative sub-decision left: it's a bounded list of DSL commands (a preset, notes, automation) that renders to audio. Leaves are measured and reviewed, then folded back into their section and the section into the song, with fix or re-emission at every level when a node's measured result misses its target.

      Tree diagram: a song node splits into sections, which split into leaves; results fold back up.
      1. Arc. One model call plans the song's sections and lengths. Freedom over form: no required drop, ~40 s cells as a soft default.
      2. Decompose. Each section splits into parts until every part is pure translation.
      3. Emit + render. Each leaf becomes DSL ops; REAPER renders it headless.
      4. Measure. LUFS, true peak, crest, spectral features and CLAP embedding go into state.json, the only thing the loop may read.
      5. Fold + review. Leaves are mixed and checked together (masking, balance), then sections against each other (seams, contrast).
      6. Fix or escalate. Retry a leaf, fix the mix, or bring it to the human.

      03 · a real build

      Tidewater Clock: seven sections, reviewed by measurement

      The first song built end to end in one session (2026-07-27): Dm9-rooted, moving Dm9 → B♭maj7♯11 → Gm11 → Csus2/A, 320 s. The arc planner chose the sections; the system built them; then the reviews ran on the rendered audio. Select a seam to see what the composer was told.

      11 / 11section pairs pass review_arc_contrast (N vs N−1 and N−2)
      4 / 6seams pass review_seam; two flagged, left for the human
      0clipped samples in the final mix, after a −8 dB master trim

      The song after it was a fresh build, not a reskin: 88 bpm, 5/4, C minor, six sections, 33 leaves, with a recurring five-note "germ cell" motif. Tempo and meter are the model's per-song decisions now. Nine leaves came out silent on the first pass, from three distinct causes, and each was fixed and checked live. Then gain staging across all 33 leaves and a mastering pass.

      04 · what it couldn't hear

      Failures a listener would have caught in a second

      Each one was found by measurement, written down, then fixed or deliberately left alone.

      05 · before any system code

      Two kill checks

      Does "good = close to the references" carry signal?

      CLAP embeddings of a machine-native reference set against a warm, performed off-target set. If they don't separate, the whole premise has nothing to steer by.

      CheckpointCohesion gapSilhouetteNN purity
      stock (HTSAT-tiny)+0.158+0.2140.995
      music (HTSAT-base) ✓+0.178+0.2500.991

      The music-trained checkpoint won both separation metrics and became canonical; every leaf and reference embedding uses it, since vectors from different checkpoints aren't comparable.

      Is headless rendering cheap enough to generate and select?

      Rendering N regions in one REAPER invocation costs a fixed ~7.6–7.9 s plus ~0.15 s per extra cheap leaf.

      Medians from exp2b_results_v2.md; "separate" is N × the single-leaf median. The first run also measured headless xvfb at 9.01 s against 24.09 s on a real display (~2.7×); the second run found them level (7.89 s vs 7.79 s), so batching is the lever that held up.

      06 · run it

      Setup

      Requires Python 3.11 exactly and a local REAPER install with Surge XT. REAPER is driven through TwelveTake-Studios/reaper-mcp. The reference audio library is user-sourced and not redistributed.

      uv venv --python 3.11
      uv pip install -r requirements.txt
      scripts/start_reaper_mcp_bridge.sh start
      # renders always go through xvfb, never a real display
      xvfb-run -a reaper -renderproject <path>
      # tests
      .venv/bin/python -m unittest discover tests
      src/return_channel/.RPP parsing, headless render, LUFS / peaks / spectral / CLAP analysis, reference scoring
      src/planner/node schema, arc, decompose, emit, fold and review, fix and escalation, gain staging, mastering, orchestration
      experiments/the two kill checks, plus ground-truth REAPER projects used as fixtures
      memory.mdthe running session log: what's built, what's broken, what's next

      Active. The record is the point; the engineering is the means.