Co-Produce AI · Part 2 of 4

The Pipeline: From a Chaotic Sample Folder to a Finished, Trained Pack

🧪 The Pipeline· ⏱️ ~28 min read· 🧩 Sections 7–26 of the toolkit

TL;DR

This is the hands-on core of Co-Produce AI: the chain that turns raw audio into a model that sounds like you, then into shippable product. Organize → remove vocals → deep listen → auto-tag → enrich with Genius → build captions → prepare/validate → train → generate → remix/flip → build beats → render through your VSTs → full songs → vocals → lyrics → finish & package.

Then the part nobody else ships: a Creative Techniques Lab — taste distillation, micro-variants, groove DNA transplants, flip lineage, destroy-and-heal, two-producer packs, Push-as-instrument, an AI session musician, and ecosystem packs — plus genre expansion into rock/metal and dubstep/DnB, all driven from one local dashboard.

📚 Part 2 of a 4-part series. Part 1 covered setup, architecture, the cloud-GPU model, and licensing. This post is the full creative pipeline. Part 3 is the reference layer — costs, engine choice, serverless, the SaaS backend, and scaling.

Every stage below is a standalone script and a dashboard tab. They compose through sidecar files, so you can run the whole chain or jump in anywhere. GPU steps default to a rented pod (see Part 1). Let's walk it.

The full chain

  1. Organize your soundbank
  2. Remove vocals (stem separation)
  3. Deep Listen — analyze any track
  4. Auto-tag — open-vocabulary mood
  5. Genius metadata enrichment
  6. Build captions — fuse it all
  7. Prepare & validate the dataset
  8. Train your model (cloud)
  9. Generate samples & packs
  10. Audio-to-audio (flip a sound)
  11. Remix — genre transform & mashup
  12. Beat builder
  13. VST3 instruments & effect chains
  14. Full songs (2–4 min)
  15. ACE Studio vocals
  16. Lyric model — write in your voice
  17. Post-process, package, provenance
  18. Creative Techniques Lab
  19. Genre expansion: rock/metal & bass music
  20. Dashboard (web UI)

7. Organize your soundbank

Stage 1 · local · pure DSP, no GPU

What it is. Turns a messy, unsorted sample library into the tagged folder structure the toolkit trains and builds from — auto-classifying kicks/snares/hats/percs/808s, drum loops, melodic loops, vocals, FX, and routing MIDI/REX/presets. Classification uses filename keywords first, then audio analysis (spectral/onset features) as a fallback, with a confidence-scored review CSV.

# preview first (nothing gets moved):
python scripts/organize_soundbank.py --input "F:/Sound Bank" --output "F:/Sound Bank Organized" --dry-run
# then do it for real (originals are copied, not moved, unless you pass --move):
python scripts/organize_soundbank.py --input "F:/Sound Bank" --output "F:/Sound Bank Organized" --resume

Files are copied (originals safe) unless --move. --dry-run previews to review.csv; low-confidence files land in _review/ for manual sorting. Folder names become training prompt tags, so name them descriptively; drop a tags.txt (comma-separated) in any folder to add era/texture descriptors.

Optional / good-to-have: --ai-tags runs local CLAP zero-shot tagging after sorting; --include-nonaudio routes MIDI/REX/Kontakt presets; on huge banks use --resume and run overnight. On Windows, enable LongPathsEnabled if deep pack folders error.

Creator tip: Those folder names and tags.txt files are your training vocabulary — "dusty," "Memphis," "70s soul," "detuned." This is where your genre knowledge becomes the moat. Spend real time here; the model can only learn the language you give it.

8. Remove vocals (stem separation)

Stage 2 · GPU (cloud pod default; runs locally on 8 GB+)

What it is. Strips vocals from a large batch of MP3/WAV to get clean instrumentals (and optional acapellas), using BS-RoFormer (current SOTA, ~12.9 dB vocal SDR) with a Demucs fallback.

pip install "audio-separator[gpu]"
python scripts/remove_vocals.py --input songs/ --output raw_beats/ --mp3 --keep-vocals --require-gpu

--require-gpu aborts rather than silently crawling on CPU. --mirror preserves subfolder structure (use when input is sorted into albums to avoid same-name collisions). It's resumable — re-run to continue.

Optional / good-to-have: --engine demucs for 4-stem separation; --keep-vocals to save acapellas for your lyric/ACE work; on a pod, write the zip to a roomy disk before runpodctl send.

Creator tip: Always keep the acapellas (--keep-vocals) even if you only want beats today. Those isolated vocals feed the ACE Studio and lyric workflows later (sections 21–22), and re-running separation on a huge archive is expensive.

9. Deep Listen — analyze any track

Stage 3 · GPU optional (PANNs/CLAP use it if present)

What it is. Learns everything possible about a file: technical truth (sample rate, LUFS, crest/dynamics, stereo correlation, clipping, band-by-band spectrum, lossy-upsample detection), musical analysis (BPM + tempo stability, key, onset density, structure, energy arc), sound identification (every event with timestamps across AudioSet's 527 classes via PANNs), and mood/genre/instrument/production (CLAP zero-shot). Outputs .analysis.json + readable .analysis.md.

pip install panns-inference laion-clap beat-this
python scripts/deep_listen.py --input track.mp3 --out reports/
# for the training pipeline, write slim caption sidecars next to the audio:
python scripts/deep_listen.py --input "F:/raw_beats" --out "F:/raw_beats" --for-captions --resume

--for-captions writes a slim <file>.caption.json (only what the caption builder needs). Pointing --out at the audio folder puts reports adjacent, so build_captions.py finds them with no extra flags.

Optional / good-to-have: --no-events/--no-vibe skip the model layers for a fast technical-only pass; run it on the pod alongside vocal removal.

This is a real QA tool, not just a tagger. The lossy-upsample flag catches fake "WAVs" — files that were MP3s re-saved as WAV. Use Deep Listen as a pre-purchase check on sample packs you're buying; it's the kind of forensic detail hosted generators never expose.

10. Auto-tag — open-vocabulary mood/vibe

Stage 4 · GPU (cloud pod default; Qwen wants 16 GB+)

What it is. Tags the feel of a beat in free-form language (not a fixed list) by having an audio-language model listen and describe it. Can tag the full mix, just the vocal, just the beat, or all stems separately.

pip install transformers accelerate
python scripts/auto_tag.py --stems-dir "F:/raw_beats" --source beat --engine qwen3-omni --resume

Engines, heaviest to lightest: qwen3-omni (most detailed) → qwen2-audio (lighter) → clap (light fallback), plus a heuristic engine (local DSP — no model, GPU, or network). --source beat tags only *_instrumental. --limit N --shuffle processes random batches; repeat runs walk the dataset with --resume.

Creator tip: Start with --limit 25 and read the tags before committing the whole archive. If the model is calling your dusty soul loops "modern EDM," your captions — and therefore your trained model — will inherit that error. Sanity-check small, then scale.

11. Genius metadata enrichment

Stage 5 · local · needs a free Genius token

What it is. Matches each beat to a Genius song by filename and writes a metadata sidecar — producer, writers, album, release year, URL (metadata only; never lyrics). Feeds real production lineage into your captions.

Get a token at genius.com/api-clients → New API Client → Generate Access Token. Then set it (it stays in your shell, never in the repo) and run:

$env:GENIUS_TOKEN = "paste_client_access_token"
pip install requests
python scripts/genius_lookup.py --beats "F:/raw_beats" --resume

macOS/Linux: export GENIUS_TOKEN=.... Persist on Windows with setx GENIUS_TOKEN "...". It cleans track numbers / _instrumental / "(OFFICIAL VIDEO)" noise from filenames, takes the best hit, and records a match_score + low_confidence flag so you can spot-check.

Production lineage as training signal: baking real producer/era metadata into captions means your model can learn associations like "Memphis, early-90s, dusty" as a coherent aesthetic — not just acoustic features. That's a depth of labeling generic text-to-music models simply don't have.

12. Build captions — fuse it all

Stage 6 · local

What it is. Composes ONE canonical training caption per beat in a consistent field order — fusing Deep Listen analysis + your auto-tags + Genius producer/era — so your model learns audio and production lineage. Leads with a subgenre only when the analysis is confident, else plain hip hop.

python scripts/build_captions.py --beats "F:/raw_beats"

Writes <beat>.caption.txt next to each file; prepare_dataset.py uses it verbatim as the training prompt. Example output:

trap, hi-hat, 808 bass, dark, modern polished production, 140 BPM,
key of F minor, loop, prod Speaker Knockerz, 2010s

Optional / good-to-have: --genre-threshold tunes how confident a subgenre must be to lead; --no-genius ignores Genius data; --dry-run previews captions before writing.

Creator tip: Read a random sample of the generated .caption.txt files out loud. If they read like how you'd describe the sound, the model will learn your aesthetic. If they read generic, go back and enrich your folder tags (section 7) — captions are only as good as their inputs.

13. Prepare & validate the dataset

Stage 7 · local

What it is. Converts your library to 44.1 kHz stereo, slices long files under the model window, auto-detects BPM/key, writes per-file prompt sidecars, then validates the set before you spend a cent on GPU.

python scripts/prepare_dataset.py --input "F:/raw_beats" --output "F:/dataset_beats" --name-contains _instrumental
python scripts/validate_dataset.py --dataset "F:/dataset_beats"

--name-contains _instrumental includes only beats (skips _vocals). Validation fails loudly on wrong sample rates, silence, empty prompts, or over-length files. For genre BPM ranges, add --bpm-min/--bpm-max (DnB 100–200 so 174 isn't folded to 87).

Creator tip: Validation is your last free checkpoint before paid GPU time. Take clipping warnings seriously, fix bad folder tags and re-run, and spot-check dataset/prepare_log.txt. A clean dataset is the cheapest possible insurance against a wasted training run.

14. Train your model (cloud)

Stage 8 · GPU · cloud pod default

What it is. Fine-tunes an open audio model on your dataset so generation sounds like your catalog. Two paths: SA3 LoRA (recommended — small adapter, ~$1–2, an hour or two, stackable per-genre) and SAO full fine-tune (maximum ownership, ~$8–40).

Mental model: cost is GPU-hours, not per-file — the loader samples random crops across thousands of steps, so a 500-file and a 3,000-file run cost about the same. You don't pick "sets at once"; you set batch size + steps. Sweet-spot dataset: 500–1,500 well-labeled, on-aesthetic files — curation beats raw count.

# on the pod (after cloud/sa3_setup.sh)
python /workspace/toolkit/scripts/sa3_workflow.py prepare --dataset /workspace/dataset_beats --data-dir /workspace/sa3_beats
cd /workspace/stable-audio-3 && uv run python scripts/train_lora.py --model medium-base \
  --data_dir /workspace/sa3_beats --rank 16 --adapter_type dora-rows --steps 2500 \
  --exclude seconds_total --output_dir /workspace/lora_beats
runpodctl send /workspace/lora_beats/lora_step2500.safetensors   # receive on your PC

Watch the trainer's demo audio and stop when it sounds like your aesthetic but not like specific files (overfitting). ~2000–3000 steps is a good range for this size. For lower VRAM, --base_precision bf16 --adapter_type lora-xs drops it to ~5.5 GB. Use the SAO full fine-tune (cloud/runpod_setup.sh then train.py) only when LoRA stops capturing your sound. ACE-Step 1.5 (MIT, no revenue cap) is a first-class alternative engine — full A/B in Part 3.

One LoRA per subgenre is the unlock. Train a boom-bap LoRA, a trap LoRA, a metal LoRA — then swap or blend them at runtime to make hybrids (trap-metal, drumstep). Hosted services give you one global model; here your model library grows with your catalog and stacks combinatorially.
Creator tip: Keep several checkpoints — the last step isn't always the best. The step right before it starts memorizing individual files is usually the sweet spot. Let your ears, not the loss number, make the call.

15. Generate samples & packs

Stage 9 · GPU · cloud pod default (runs locally on 8 GB+)

What it is. Batch-generates audio from a pack plan (counts, durations, prompts) using your fine-tuned model. Over-generate 2–3× and curate hard.

# SA3 + your LoRA from a pack plan -> generated/<category>/
python scripts/sa3_workflow.py plan --model medium-base --lora hiphop_v1.safetensors --plan prompts/pack_plan.example.json --out generated
# SAO full-fine-tune checkpoint
python scripts/generate.py --model-config model_config.json --ckpt hiphop_v1.ckpt --plan prompts/pack_plan.example.json --out generated --steps 100 --cfg 7
# base-model sanity check (no training) to test the pipeline
python scripts/generate.py --pretrained stabilityai/stable-audio-open-1.0 --plan prompts/pack_plan.example.json --out test_gen --steps 80

Edit prompts/pack_plan.example.json using the same tag vocabulary you trained with. --cfg is prompt adherence (6–9). SA3 also has fill (inpaint a region) and extend (continue a clip) modes.

Creator tip: Match your generation prompts to your training captions word-for-word where you can. The model learned your vocabulary — prompting it in that same language is how you get output that sounds like your catalog rather than the base model.

16. Audio-to-audio (flip a sound)

Stage 10 · GPU

What it is. Feed any WAV and get new sounds derived from it, steered by a prompt — the model treats your file as the diffusion seed; --strength sets how far it transforms (0.2 re-texture → 0.5 real flip → 0.8 loose inspiration).

# real flip of a drum break (0.5 = clearly transformed but recognizable)
python scripts/audio2audio.py --model-config model_config.json --ckpt hiphop_v1.ckpt --input break.wav \
  --prompt "hip hop, boom bap, 90 BPM, dusty drum break, vinyl texture" --strength 0.5 --variations 4 --out flipped
# subtle re-texture (0.2) — same groove, new character
python scripts/audio2audio.py --model-config model_config.json --ckpt hiphop_v1.ckpt --input loop.wav --prompt "warm vinyl, tape saturation" --strength 0.2 --out retex
# no trained model yet? flip with the base model
python scripts/audio2audio.py --pretrained stabilityai/stable-audio-open-1.0 --input break.wav --prompt "lofi hip hop drums" --strength 0.5 --out flipped

Optional / good-to-have: only feed audio you have rights to (outputs are derivative); run results through postprocess.py.

17. Remix — genre transform & mashup

Stage 11 · GPU

What it is. A pure remixer: re-imagine a finished track as hip-hop / rock-metal / dubstep / DnB (full), or fuse a target genre with the track's current vibe (mashup).

# full DnB remix of any track
python scripts/remix.py --pretrained stabilityai/stable-audio-open-1.0 --input song.wav --genre dnb --mode full --variations 3 --out remixes
# rock/metal MASHUP that keeps the original's hip-hop bones
python scripts/remix.py --model-config model_config.json --ckpt hiphop_v1.ckpt --input song.wav --genre rockmetal --mode mashup --current "boom bap hip hop" --out remixes

Strength auto-picks (full 0.6 / mashup 0.4). Quality scales with the model — a per-genre LoRA makes remixes far more convincing than the base model. Also available as a Remix tab and a remix-the-selected-file panel inside the dashboard's Audition view.

18. Beat builder — beats from your samples

Stage 12 · local · no GPU needed

What it is. Sequences kicks/snares/hats/percs/808s from your organized library on style grids (boom_bap, trap, drill, lofi, rock, metal, dbeat, dubstep, dnb, amen) with swing + humanization, layers a melodic loop, and outputs master + stems + pattern.mid + a manifest of exactly which samples were used.

# classic boom bap, 4 bars, 8 beats to choose from, with a melodic layer
python scripts/beat_builder.py --library "F:/SoundBankAI" --style boom_bap --bpm 90 --bars 4 --count 8 --melodic "F:/SoundBankAI/melodic_loops" --out beats
# drill, every hit a different sample (human feel)
python scripts/beat_builder.py --library "F:/SoundBankAI" --style drill --bpm 142 --rotate --out beats_drill

--rotate picks a different sample per hit (pair with micro-variants for human feel); --groove file.groove.json applies an extracted groove (section 24). pattern.mid drops onto an Ableton Drum Rack (GM mapping: kick 36, snare 38, hat 42, perc 47, 808 35).

It tells you exactly what it used. Every built beat ships a manifest.json listing the precise source samples — and a pattern.mid you can drag into any DAW. That transparency and DAW-native handoff is the opposite of a black-box "generate a beat" button.

19. VST3 instruments & effect chains

Stage 13 · local

What it is. Drive your real plugins headlessly with pedalboard — render MIDI through your instruments (Battery, Massive, Kontakt, FM8…) and process audio through your effects (Saturn, tape, comps, limiters). A scanner catalogs what's installed.

pip install pedalboard
python scripts/plugin_scan.py                                   # build plugins_catalog.json
# render a beat's MIDI through your Battery kit AND glue it in one step
python scripts/vst_instrument.py --vst3 "C:/Program Files/Common Files/VST3/Battery 4.vst3" --midi beats/boom_bap_90bpm_01/pattern.mid --chain configs/vst_chains/dusty_boombap.json --out kit_dusty.wav
# dusty boom-bap glue on a folder of processed samples
python scripts/vst_chain.py --input processed --output processed_dusty --chain configs/vst_chains/dusty_boombap.json

Ready-made chains live in configs/vst_chains/ (dusty boom-bap, metal master, bass-music mangle, destroy chain, Ozone vocal-suppress). Use --edit N to dial a plugin's GUI once; settings apply to the whole batch. --list-params prints automatable names.

Your plugins become part of the model's sound. The killer move: run your training dataset through a character chain (your tape, your saturation) before fine-tuning, so the model learns your sonic identity baked in. No hosted generator can render through the actual licensed plugins on your machine.

20. Full songs (2–4 min)

Stage 14 · GPU · cloud pod default

What it is. Beyond loops — complete tracks. Instrumental songs via Stable Audio 3 (up to ~380 s, works with your beat LoRA); songs with vocals from your lyrics via HeartMuLa (Apache-2.0, no revenue cap).

# instrumental (SA3), works with your LoRA:
python scripts/sa3_workflow.py song --model medium --lora my.safetensors --prompt "boom bap instrumental, 90 BPM, F minor, vinyl" --duration 180 --out song.wav
# vocals + lyrics (HeartMuLa):  bash cloud/heartmula_setup.sh
python scripts/song_generate.py --heartlib /workspace/heartlib --ckpt /workspace/heartlib/ckpt --lyrics-file prompts/song_lyrics.example.txt --tags "boom bap,hip hop,male vocals,dusty,90 bpm" --duration 3 --out song.mp3 --lazy-load

HeartMuLa wants 16 GB+ (--lazy-load on a single GPU). Lyric sections use [Intro]/[Verse]/[Chorus]/[Bridge]/[Outro]. The MIT engine (ACE-Step) can do instrumental or vocal in one model — see Part 3.

21. ACE Studio vocals

Stage 15 · local prep + ACE Studio app

What it is. The highest-control vocal path — ACE Studio (you own it + ACE Bridge in Ableton) turns MIDI + lyrics into sung/rapped vocals. The toolkit prepares ACE's inputs: a flow/melody MIDI aligned to your beat's key + BPM, plus a syllable-segmented lyric file.

# rap flow MIDI auto-keyed/timed from a beat (reads BPM/key from its Deep Listen sidecar)
python scripts/vocal_guide.py --beat "F:/raw_beats/MyBeat_instrumental.mp3" --lyrics verse.txt --style rap --out guide
# feed a generated verse straight in (lyric model -> ACE)
python scripts/lyric_generate.py --model-dir lyric_model --mode verse --mood dark --out verses && \
python scripts/vocal_guide.py --bpm 90 --key "F minor" --lyrics verses/verse_dark_01.txt --style rap --out guide

--style rap = rhythmic monotone scaffold; --style sung = stepwise topline in the key's scale. Then in ACE Studio: import guide.mid, paste guide_lyrics.txt onto the notes, pick a voice, render; ACE Bridge plays it over the beat in Ableton.

22. Lyric model — write in your voice

Stage 16 · local Ollama · fully private

What it is. Train on your years of lyrics, profile your style (flow density, rhyme rate, vocabulary, themes, mood), then generate new verses/hooks in your voice with a local Ollama model — fully private. Then seed a beat from any verse.

# profile your style first (once)
python scripts/lyric_analyze.py --input "F:/RAP_ARCHIVES/lyrics" --out lyric_model
# one-time: install Ollama (ollama.com), `ollama pull llama3.1:8b`, `pip install requests`
# a dark 16-bar verse on a theme
python scripts/lyric_generate.py --model-dir lyric_model --mode verse --mood dark --theme "grinding through the cold" --bars 16 --out verses
# turn a generated verse into a matching beat brief (genre/BPM/key + commands)
python scripts/lyric_to_beat.py --lyrics verses/verse_dark_01.txt --out beat_brief

llama3.2:3b is snappier on small GPUs, or run Ollama on a cloud pod for higher quality.

Creator tip: Small corpora make the model echo your phrasing hard — treat every output as a draft in your voice, not a finished verse. The win isn't automation; it's a tireless co-writer that already knows your cadence and themes.

23. Post-process, package, provenance

Stage 17 · local

What it is. Turns raw generations into release-quality samples (reject duds, trim, anti-click fades, loudness-normalize, re-detect BPM/key, 24-bit), assembles a standard sellable pack (One Shots / Loops / Stems, producer-style names, README + license + zip), and writes a provenance certificate.

python scripts/postprocess.py --input generated --output processed --lufs -14
# ---- HUMAN QA: listen to everything in processed/, delete the weak ones ----
python scripts/build_pack.py --input processed --pack-name "Dusty Crates Vol 1" --out packs
python scripts/provenance.py --pack packs/DustyCratesVol1 --dataset dataset --generated generated --run-name beats-v1 --statement "All training audio owned/cleared."
Creator tip: Human QA is non-negotiable for a paid product. A 200-sample pack should come from 500+ generations. The model gets you 80% of the way; your ears do the rest. Publish a public hash-verifier so buyers can confirm a pack's origin against its provenance cert.

24. Creative Techniques Lab

Techniques the AI-beat crowd isn't doing — built on the loops between the tools. In the commands below, <MODEL> means either your trained model (--model-config model_config.json --ckpt hiphop_v1.ckpt) or the base (--pretrained stabilityai/stable-audio-open-1.0). Most are GPU-backed.

Taste distillation — curation_loop.py

CLAP-rank generations against a folder of your best sounds, keep the closest, retrain on the keepers. Your ear becomes the training signal.

# rank 500 generated kicks against your 30 favorites, keep the top 10%
python scripts/curation_loop.py score --candidates generated/Kicks --reference my_best_kicks --keep-top 0.1 --keep-dir round2/kicks
# turn the keepers into the next fine-tune dataset, then retrain on it
python scripts/curation_loop.py promote --keep-dir round2 --dataset-dir dataset_round2 --base-prompt "hip hop, dusty"

Micro-variants — microvariants.py

8 subtle takes of each one-shot via low-strength audio-to-audio; pair with beat_builder --rotate so no two hits are identical (like a real drummer).

python scripts/microvariants.py <MODEL> --input organized/drums_oneshots/kicks --variants 8 --strength 0.15 --prompt "hip hop, kicks, one shot, punchy" --out variants/kicks
python scripts/beat_builder.py --library variants --style boom_bap --rotate --bpm 90 --out beats_human

Groove DNA — groove_dna.py

Extract a break's micro-timing + accents into a template (numbers, not audio — no rights issue); apply to your samples via beat_builder --groove. "Quantize to Dilla."

python scripts/groove_dna.py --input classic_break.wav --name dilla_a --out grooves
python scripts/beat_builder.py --library "F:/SoundBankAI" --style boom_bap --bpm 90 --groove grooves/dilla_a.groove.json --out beats_dilla

Flip lineage — flip_lineage.py

Chained audio-to-audio (a telephone-game morph); every stage's prompt/strength/seed/hash is logged to lineage.json. The evolution itself is content.

python scripts/flip_lineage.py <MODEL> --input soul_loop.wav --out lineages/soul \
  --stage "0.3:hip hop, soul keys, dusty" --stage "0.35:hip hop, dark strings, tape" --stage "0.4:hip hop, eerie synth, lofi"

Destroy-and-heal — destroy_heal.py

Wreck audio through an extreme VST chain, then low-strength a2a heals it back toward musicality — the scars that survive are the texture. The bass-music machine.

python scripts/destroy_heal.py <MODEL> --input loops --chain configs/vst_chains/destroy_extreme.json \
  --prompt "hip hop, dusty vinyl, warm analog" --heal-strength 0.25 --out healed

--heal-strength 0.15 keeps it gnarly, 0.4 leans on the model to smooth it; add --keep-destroyed to A/B the wreck vs the heal.

Two-producer packs — ab_models.py

Same seeds + same plan through two LoRAs; item N in A/ and B/ is the same idea in two sonic personalities.

python scripts/ab_models.py --plan prompts/pack_plan.example.json \
  --model-a-config cfgA.json --model-a-ckpt soul70s.ckpt \
  --model-b-config cfgB.json --model-b-ckpt memphis90.ckpt --out ab_packs --base-seed 1234

Push as an instrument — push_generation_server.py

An OSC server holds your model in memory; map Push pads/knobs (via Live's free Connection Kit OSC Send) to fire generation jobs — generation becomes performance.

python scripts/push_generation_server.py <MODEL> --presets prompts/push_presets.example.json --out "C:/Ableton/GenSamples"

AI session musician — call_response.py

Watches a folder; every clip you export from Live gets answered with N variations in a response folder. Trade bars with a model trained on your catalog.

python scripts/call_response.py <MODEL> --watch "C:/Ableton/Call" --respond "C:/Ableton/Response" --prompt "hip hop, soul keys response" --strength 0.45 --variations 2

Ecosystem packs — ecosystem_pack.py

Lock a whole pack series to one key + BPM so every volume inter-combines; verify quarantines mismatches. Modular packs a loose catalog can't promise.

python scripts/ecosystem_pack.py plan --base prompts/pack_plan.example.json --key "F minor" --bpm 90 --name "Crate Ecosystem Vol 2" --out prompts/eco_fmin_90_v2.json
python scripts/ecosystem_pack.py verify --dir processed --key "F minor" --bpm 90
This is the section no competitor has. Taste distillation, groove transplants, destroy-and-heal, locked ecosystem packs, generation-as-live-performance — these are emergent techniques that only exist because the toolkit is an open pipeline of composable scripts. A single prompt box can't do any of them.

Run-time note: most Creative-Lab scripts are one-and-done. Three are different: push_generation_server.py (a server) and call_response.py (a folder watcher) are long-running — they stay up streaming logs until you stop them (Ctrl-C). And ableton_bridge.py needs Ableton Live already open with its OSC listener active (default 127.0.0.1:11000).

25. Genre expansion: rock/metal & dubstep/DnB

What it is. The same pipeline runs three product lines. What changes per genre: library labels, BPM conventions, and pattern grammars.

# metal — double-kick under a halftime backbeat at 168
python scripts/beat_builder.py --library "F:/SoundBankAI" --style metal --bpm 168 --bars 4 --count 6 --out beats_metal
# DnB two-step / amen at 174 (prep data with --bpm-min 100 --bpm-max 200 so 174 isn't folded to 87)
python scripts/beat_builder.py --library "F:/SoundBankAI" --style dnb --bpm 174 --bars 4 --count 6 --out beats_dnb

Beat-builder styles add rock metal dbeat dubstep dnb amen to the hip-hop set. Strategy: one LoRA per genre (don't mix); stack them for hybrids. Build genre packs from prompts/pack_plan.rock_metal.json and prompts/pack_plan.dubstep_dnb.json.

Creator tip: Your QA ears change per genre — metal: listen for flabby chugs and fake cymbal decay; bass music: check sub weight (30–60 Hz) and LFO-locked wobbles, and plan 3–4× overgeneration. Tuning-locked metal series and exact-174 DnB packs are ecosystem products nobody else ships.

26. Dashboard (web UI)

What it is. A local Gradio control panel for the whole suite — a tab per stage grouped into sections (Prep & Analyze · Train & Generate · Beats & Sound · Remix · Lyrics · Finish · Plugins), each with live streaming logs, plus an Audition tab with playback and a remix-the-selected-file panel, a 🧪 Creative Lab tab, a ☁️ Cloud / Deploy reference tab, and a 🛰️ Server / API tab that launches the SaaS API/worker, runs the test suite, and drives the API client (signup→submit→download). Every runnable script in scripts/ is reachable from the UI.

pip install gradio
python dashboard.py     # or run_dashboard.bat  ->  http://127.0.0.1:7860

GPU steps run wherever you launch it — locally, or run the dashboard on a cloud pod and open its forwarded port to drive the rented GPU from the same UI. (Behind a VPN/proxy it auto-falls back to a share link.)

Creator tip: The dashboard is the fastest way to learn the toolkit — every form maps to a CLI flag, and the live log shows you the exact command. Click your way through a workflow once, then copy the commands into scripts when you want to automate it.

Next up — Part 3: Reference & Scaling →

You can now take raw audio all the way to a finished, trained pack. Part 3 is the reference layer that turns this from a workflow into a business: training specs and the real GPU-cost math, sourcing lossless audio, the Stable Audio 3 vs ACE-Step 1.5 engine decision, hosting the toolkit as a serverless endpoint, the SSH/SCP pod workflow, and the full SaaS backend — job queue, REST API, and Stripe billing.

Read Part 3: Reference & Scaling →

Project on GitHub. Co-Produce AI web services go live Fall 2026 — in development now, ~80% of the SaaS backend built, with test runs running locally from the dashboard launcher.