Open source · keyboard-first · AGPL-3.0

Taste in. Tracks out.

Setloom is a keyboard-first harness for producing club tracks. You give direction in plain language; the agent writes the source, renders the audition, and inspects the result. You listen and say what is wrong. You never open a DAW.

The human is the taste owner. The agent does the production labor.


The premise

Music production has a gatekeeper: the interface.

The piano roll, the plug-in maze, the mixing-desk vocabulary: decades of craft stacked between you and the idea already playing in your head. Setloom removes it. The only skills it asks for are the ones you have already, hearing a track and knowing whether it moves you.

How it works

Three roles, one loop.

One division of labor runs the system. The human is the taste owner; the agent does everything else.

01

Taste owner

you

You give direction in plain language: the bass is too busy before the break; make the arp darker. You make every musical decision, and nothing is final until you say so.

02

Producer

the agent

It turns direction into concrete source changes: writes the track's own code, renders a fresh audition, plays it back, and reports the tradeoffs. It proposes; it does not decide.

03

Studio

the harness

A small, unopinionated toolkit that scaffolds tracks, renders, inspects audio, and keeps the work reproducible. It owns technical hygiene only. It composes nothing.

The loop

Audition, react, revise.

Every pass is short. The agent prepares and plays the audio; you listen and type. The gate is no-click.

01producer thesis
02source edit
03render audition
04play and inspect
05listening note
06revise or promote

Machine reports and plots are diagnostics. The verdict is a person listening.


The tool drawer

A small toolkit, run from the keyboard.

CLI-controllable tools and opt-in diagnostics. It never composes the music; each track's own source does that.

Scaffold a track

setloom new

Spec, runnable assembler, and listening-notes template from a single command.

Render from source

assemble.py

Each track's editable code assembles the music. Every render is reproducible.

Inspect audio

setloom inspect

Waveform, spectrum, spectrogram, stereo field, and A/B comparisons from the CLI.

Recover notes

setloom transcribe

Pull note candidates from reference audio with a local macOS path.

Import primitives

setloom.midi · audio · conductor

MIDI, DSP hygiene, and music-theory math that your track code builds on.

Drive real surfaces

scsynth · Logic Pro

SuperCollider for scriptable synth lanes; Logic Pro as a local reference surface.

Quick start

One repo-local environment.

Setloom runs through a single uv project. Everything generated is file-based and reproducible.

setloom — zsh
# scaffold a track; assemble.py starts as a skeleton the agent fills in
$ uv run setloom new T06 --title midnight-signal --bpm 124 --key "F# minor"
$ uv run --no-sync python music/tracks/T06/assemble.py

# audition and inspect the render
$ uv run setloom play local/candidates/T06/seed-0/demo.wav
$ uv run setloom inspect local/candidates/T06/seed-0/demo.wav --view all

# study a reference: recover its notes, then read its anatomy
$ uv run --group transcription setloom transcribe reference.wav --out tmp/notes.mid
$ uv run setloom anatomize local/corpus/audio --layers

Where it stands

Not a one-click generator. Composition is not solved.

What works today is the loop: an agent that turns feedback into concrete source changes quickly, researches when it helps, renders and inspects reproducibly, and keeps the workspace clean enough that the next pass continues without forensics.

The leverage is disciplined iteration, not automation that replaces judgment. Setloom is honest about where that frontier sits.