Przejdź do treści
Biblioteka skilli
Marketing i treści · Automatyzacja

livebridge

/livebridge

Steruje Ableton Live 12 przez narzędzia MCP: tworzy beaty, linie basowe, akordy, miksuje, nagrywa i ładuje wtyczki.

Licencja
MIT
Ostatnia zmiana repozytorium
12.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
10
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 12.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Steruje Ableton Live 12 przez narzędzia MCP: tworzy beaty, linie basowe, akordy, miksuje, nagrywa i ładuje wtyczki.

Wyzwalacze z opisu

AbletonLivemy trackthe DAWmusic production
Oryginalny opis (EN)

Control Ableton Live 12 through the LiveBridge MCP tools (live_*). Use whenever the user wants to make, edit, arrange, mix or play music in Ableton Live - beats, drum patterns, basslines, chords, melodies, loading instruments/effects/VST/AU plug-ins (Serum 2 included), setting device parameters, clips, scenes, arrangement, automation, recording, bouncing, tempo, routing - or wants Splice samples in their Live set, or asks about their Live set, even if they just say "Ableton", "Live", "my track", "the DAW" or "music production".

Jak działa

  1. 1. Start every session the same way
  2. 2. Conventions
  3. 3. Prefer composite tools (fewer round trips, one undo step)
  4. 4. The full production recipe (8 bars, ~25 calls)
  5. 4b. Check your work: theory and ears
  6. 4c. Remember, keep sounds, generate, compare
  7. 5. Instruments, effects, plug-ins, samples, parameters
  8. 6. Splice
  9. 7. Safety and etiquette
  10. 8. Token economy
Sekcje z nagłówków SKILL.md, w oryginale · 427 linii, 4 769 słów
Podgląd SKILL.md
---
name: livebridge
description: Control Ableton Live 12 through the LiveBridge MCP tools (live_*). Use whenever the user wants to make, edit, arrange, mix or play music in Ableton Live - beats, drum patterns, basslines, chords, melodies, loading instruments/effects/VST/AU plug-ins (Serum 2 included), setting device parameters, clips, scenes, arrangement, automation, recording, bouncing, tempo, routing - or wants Splice samples in their Live set, or asks about their Live set, even if they just say "Ableton", "Live", "my track", "the DAW" or "music production".
---

# Working in Ableton Live with LiveBridge

LiveBridge gives you ~218 `live_*` tools that drive a running Ableton Live 12 through its Live
Object Model. Every mutating call is **one undo step** in Live. You cannot hear the result
directly - you work from notes, parameters, names, level meters (`live_mixer_meters`), the two
analysis tools (`live_theory_analyze` for MIDI, `live_audio_analyze` for audio - section 4b) and
the user's feedback, so describe what you did in musical terms and invite them to listen.

**Making music, not just clips**: before arranging, building transitions/build-ups, choosing
effects or mixing, read **`PRODUCTION.md`** next to this file (MCP resource
`livebridge://production`): energy curves, section blueprints per genre, the build-up and
transition toolbox, effect chains, harmony/melody rules, density, mix targets, a finishing
checklist, melody craft (the seven traps, motifs, tension notes) and turning a mood into notes. A track must work as a whole: plan the sections first, make every part serve one
idea, check theory and sound with the analysis tools.

More companions next to this file (also MCP resources), read the one that fits the request:

| File | Resource | Read it when |
|---|---|---|
| `GENRES.md` | `livebridge://genres` | writing drums, bass, chords or sounds in a named genre: techno, hardgroove, house, UK garage, speed garage, trance, Reese/growl/dubstep, synthwave, acid, ambient, hip-hop/trap/DnB grooves, loop-to-track |
| `SERUM.md` | `livebridge://serum` | designing or tweaking a Serum 2 sound: parameter cheat sheet, recipes (sub, 808, Reese, growl, acid, supersaw, pluck, pad, riser), what the API cannot change, every Serum 2 control (oscillator modes, granular, spectral, routing, matrix, FX racks) |
| `SERUM_PRESETS.md` | `livebridge://serum-presets` | a Serum 2 sound beyond the 128 exposed knobs: a new preset designed as a file (wavetables, oscillator modes, matrix routes, FX order), "make this preset darker/faster", copying a wavetable or FX rack from another preset, then `live_preset_load` |
| `OMNISPHERE.md` | `livebridge://omnisphere` | designing or improving an Omnisphere 2/3 sound: sources, granular, filters, modulation, Orb, effects, recipes; what Live can reach (Configure) |
| `MASSIVE.md` | `livebridge://massive` | designing or tweaking a Native Instruments Massive (classic) sound: what the shipped map exposes, the plain and routed templates (modulation routings are not reachable from Live), the layout, recipes (sub, Reese, wobble, pluck, pad, lead) |
| `SURGE_XT.md` | `livebridge://surge-xt` | designing a Surge XT sound: writing patches with `live_surge_write` (routings, step sequencers synced to tempo, wavetables, oscillator / filter / FX types), loading them into Live with every exposed knob right, knob names per oscillator type, recipes (stepped filter, wavetable pad, FM bass, Reese, pluck, vibrato lead) |
| `WORKFLOWS.md` | `livebridge://workflows` | extending an arrangement, co-writing parts with the user, starting a project, grooves and MIDI cleanup, chords, mix diagnosis, side-chain, reference matching, mix check / pre-master audit, vocal chain, session snapshot, technical check, parallel compression, mastering chain, send effects, adding one section (drop, breakdown, buildup, intro, outro), designing a synth sound with its manual-settings hand-off, transitions per genre, a sound check before building, balancing and mastering by measurement |

## 1. Start every session the same way

1. `live_status` - is Live reachable, which version/edition, is `allow_eval` on?
   - `type: "connection"`: tell the user to start Live and enable **Preferences -> Link, Tempo &
     MIDI -> Control Surface -> LiveBridge** (Input/Output: None). For another computer:
     `live_discover`, then `live_connect(host, port, token, persist=true)` (ask the user for the
     token; it is in the Live machine's `Remote Scripts/LiveBridge/config.json`).
   - `type: "auth"`: token mismatch - ask the user for the right token, then `live_connect`.
2. `live_set_snapshot` - tempo, signature, tracks (with `path`), devices, clips, scenes, selection.
   Big set? `detail="minimal"` first, then `live_tracks_get` / `live_clip_list` for details.
3. `live_view_selection` when the user says "this track", "this clip", "the selected device".
4. `live_memory_recall()` - what was decided and what is still open in this project (matched
   to the open set) plus the user's general preferences. Mention the open ideas briefly.

Re-snapshot after structural changes: indices shift when tracks, scenes, devices or clips are
added or removed. Prefer the `path` fields from the latest summary, or names.

## 2. Conventions

- **Time is in beats** (quarter notes). In 4/4 a bar = 4 beats; a 16th = 0.25. Note starts are
  clip-relative. Song positions, loop points and clip lengths also take Live's bars.beats.16ths
  as a string ("17.1.1" = bar 17; lengths are 0-based, "4.0.0" = 4 bars); clip/arrangement tools
  also accept `unit="bars"`; `live_time_convert` converts either way.
- **Pitch**: 60 = C3 (Live naming). Bass lives around C1-C2 (36-48), chords C3-C4, leads C4-C5.
  Note names ("F#2", "Bb3") work everywhere.
- **Drum Rack pads**: kick 36 (C1), rim 37, snare 38, clap 39, closed hat 42 (F#1), open hat 46,
  crash 49, ride 51 - `live_clip_write_pattern` takes these names and maps them onto the loaded
  kit's **pad names** (check `result.kit` and `warnings`; `live_drumrack_overview` shows the pads).
- Tracks, scenes, devices, clips accept an **index, a name (exact, then prefix) or a LOM path**
  in every tool. Tracks also take `"selected"`, `"master"` and return letters (`"A"` = first
  return); clips take `"selected"` (the clip in the Detail view); `slot` also takes a scene name.
- Colours (`color=`): a palette index 0-69, "#RRGGBB", `[r, g, b]` or a name ("red", "blue").
  Some create tools call it `color_index` (0-69) - check the schema; unknown argument names are
  rejected with the accepted list.
- **Name and colour what you create** (`name=`, `color=` on create tools): the user must recognise
  your tracks and clips.
- Volume/pan/sends in **dB text** ("-6 dB", "C", "L20"); device parameters by name and by the
  text the knob shows ("250 ms", "1.5 kHz", "Saw", "1/8"; compound displays such as Serum's
  "50% [-9.0 dB]" take "70%" or "-6 dB"). Read before you write
  (`live_device_parameters(filter=...)`) so you use the parameter's own units.

## 3. Prefer composite tools (fewer round trips, one undo step)

| Goal | Tool |
|---|---|
| New track with an instrument | `live_browser_load(query, category="instrument", new_track=true, track_name=...)` - or `live_tracks_create` + `live_device_insert(name)` for plain built-ins (Live 12.3+, fastest) |
| Drum kit | `live_browser_load("909 Core Kit", category="drum_kit", new_track=true, track_name="Drums")` |
| Serum 2 / a big VST3 synth | `live_plugin_expose(plugin="Serum 2", parameters=["sound_design"], new_track=true, track_name=...)` (loads it already controllable) |
| Every parameter of any VST3 (past 128), no automation needed | `live_plugin_host_load(plugin="Diva")` then `live_plugin_host_parameters(search="cutoff")` / `live_plugin_host_set(values={"VCF1: Cutoff": "800 Hz"})` — experimental, Max for Live; to automate some of them, `live_plugin_host_bank(parameters=["VCF1: Cutoff", ...])` turns them into Live dials; `live_plugin_host_preset(source_path=...)` loads a `.vstpreset` or a Serum 2 design into the hosted plug-in, so a file-designed patch can be fine-tuned knob by knob |
| Tune any VST3 (not Serum: that has preset files) with the ≤128 controls that matter | scout in a host: `live_plugin_host_load` (or `live_plugin_host_preset` with the user's saved `.vstpreset`), **first** `live_plugin_host_parameters(touched="reset")` (the log keeps everything since the host started, including restore bursts), then the user tweaks the plug-in's window, then `live_plugin_host_parameters(touched=true)` lists only what they moved (in order, before → after) — see §4b; if it stays empty, `snapshot="before"` then `changed_since="before"`; pick ≤128 (moved first, then what the patch uses, then the role's defaults); `live_plugin_host_expose(parameters=[...])` saves the patch, loads the plug-in natively in a rack with those parameters exposed and removes the host. `live_plugin_host_save` alone writes the patch as a `.vstpreset` |
| A whole Serum 2 patch (wavetables, matrix, FX order) | design the preset file: `live_preset_find(query=...)` for a starting preset, `live_preset_edit(...)`, then `live_preset_load(source_path=...)` — `SERUM_PRESETS.md` |
| Drum/arp/bass step pattern | `live_clip_write_pattern` (creates the clip) |
| Chord progression | `live_clip_write_chords("Am7 Fmaj7 C G", voice_leading=true)` - Roman numerals in the song key work too ("i VI III VII") |
| Arpeggio | `live_clip_write_arp(chords="Am F C G", style="up", rate="1/16")` |
| Free notes | `live_clip_add_notes(notes=[["C3",0,1,100], ...], create=true)` |
| Groove/feel | `live_clip_transform_notes(quantize=..., swing=..., humanize_timing=..., velocity_scale=..., fit_scale=true, transpose_steps=...)`; Groove Pool: `live_groove_pool` + `live_clip_set(groove=...)` |
| Many mixer changes | `live_mixer_set_many` |
| Many parameters | `live_device_set_parameters` |
| A long build (many commands) | `live_command_batch([{cmd, args}, ...])` - bridge commands (see `live_commands`), one round trip, **one undo step**, `"$0.path"` references earlier results |
| Everything about the set | `live_set_snapshot` |

## 4. The full production recipe (8 bars, ~25 calls)

Genre starting points (tempo, feel, key):

| Genre | Tempo | Drums | Key / harmony |
|---|---|---|---|
| House | 122-126 | four-on-the-floor kick, clap on 2+4, off-beat open hat | minor, i-VI-III-VII |
| Techno | 128-135 | kick every beat, closed 16th hats, sparse clap | minor/phrygian, one chord + stabs |
| Hip-hop / boom bap | 85-95 | kick 1 + "and of 2", snare 2+4, swung hats (`swing=0.55`) | minor 7ths, ii-V |
| Trap | 140 (half-time feel) | 808 kick, snare on 3, 1/32 hat rolls | minor, dark pads |
| Drum & bass | 172-176 | two-step kick/snare, fast hats | minor, long pads |
| Lo-fi | 70-85 | swung, humanized, low velocity | major 7ths/9ths |

1. **Set** - `live_transport_set(tempo=124, signature="4/4")`; sections first if the user wants
   a song: `live_cue_layout(cues=[{"name":"Intro","bar":1},{"name":"Drop","bar":9}])` (works
   before any clip exists).
2. **Drums** - `live_browser_load("909 Core Kit", category="drum_kit", new_track=true,
   track_name="Drums")`; `live_drumrack_overview(track="Drums")` to see which pads hold what;
   `live_clip_write_pattern(track="Drums", slot=0, pattern={"kick":"x...x...x...x...",
   "clap":"....X.......X...", "hat":"..x...x...x...x.", "ohh":"......x.......x."}, repeat=8)`
   (8 bars of 16ths; check `result.kit` / `warnings` for rows that hit an empty pad).
   Samples onto pads: `live_drumrack_set_pad(note="C1", track="Drums", file_path=...)`.
3. **Bass** - `live_browser_load("Sub Bass", category="instrument", new_track=true,
   track_name="Bass")` (or `live_device_insert("Drift")` on a new MIDI track), then
   `live_clip_add_notes(track="Bass", slot=0, create=true, notes=[["A1",0,0.75],["A1",1.5,0.5],
   ["A1",2.5,1], ["F1",4,0.75], ...])` - roots (plus fifths/octaves), rhythmic gaps,
   monophonic, below C3. **Browser presets usually load as racks with macros**: shape them with
   `live_rack_macros(track="Bass", values={"Filter": 40})` (read it first); use
   `live_device_set_parameters` on the inner device path only when no macro covers it.
4. **Chords / pad** - `live_browser_load("Warm Pad", category="instrument", new_track=true,
   track_name="Pad")`; `live_clip_write_chords(track="Pad", slot=0, chords="Am7 Fmaj7 C G",
   duration=8, octave=3, voice_leading=true, velocity=80)` (4 chords x 8 beats = 8 bars);
   optional `live_clip_write_arp` on a lead.
5. **Serum 2 lead (optional)** - `live_plugin_expose(plugin="Serum 2",
   parameters=["sound_design"], new_track=true, track_name="Lead")` -> set the sound with
   `live_device_set_parameters(device=<returned device>, values={"Filter 1 Freq": "1.2 kHz",
   "Env 1 Attack": "5 ms", "A Octave": "+1 oct"})`.
6. **Splice sample (optional, credits!)** - see section 6: search -> ask -> download ->
   `live_splice_import_downloaded(files=[...], track=..., mode="session", warp=true)`; match
   key with `live_clip_set(pitch_coarse=...)`, check the warp with `live_clip_warp`.
7. **Effects** - `live_device_insert("EQ Eight", track=...)` with a **low cut** on everything
   that is not kick/bass (~100-150 Hz on pads/leads/hats); `Compressor` on the drum bus;
   `Utility` for gain (its knob is "Output"); returns: `live_device_insert("Reverb",
   track="A")` / `("Delay", track="B")` and `live_mixer_set(track="Pad", sends={"A": "-12 dB"})`.
   **Side-chain** the bass/pad to the kick: `live_device_insert("Compressor", track="Bass")`,
   then `live_routing_route(source="Drums", destination="Bass", method="sidechain")`.
   Group devices into a rack: `live_device_insert("Audio Effect Rack")`, `live_rack_insert_chain`,
   `live_device_move(target_chain=...)`.
8. **Gain staging / mix** - `live_mixer_set_many`: kick/drums around -6 dB, bass -8, pads -12,
   leads -10, returns -15 dB; `live_mixer_master(volume="0 dB")` with a Limiter last on the
   master. Play and read `live_mixer_meters(seconds=3)`: the master peak must stay below ~0.9
   (about -1 dBFS headroom; aim for -6 dB on the master before the limiter), no instrument track
   silent (peak 0 means nothing sounds - check notes, device on, routing).
9. **Arrangement** - put the variations in scenes, then `live_arrangement_from_scenes(sections=
   [{"scene":"Intro","bars":8}, {"scene":"Drop","bars":16}])`; extend loops with
   `live_arrangement_duplicate_clip(length=...)` / `live_arrangement_resize_clip`; check with
   `live_arrangement_overview`.
10. **Automation** - sweeps into session clips: `live_automation_shape(parameter="Filter Freq",
    shape="ramp_up", mode="events", track=..., slots=[0, 1, 2])` (several scene clips at once);
    show it with `live_view_clip_editor(envelope="Filter Freq")`. Clip envelopes survive the copy
    to the arrangement only on tracks without an instrument (check `envelopes.copied` in the
    duplicate result); **track automation in the arrangement**: `live_automation_record(parameter=
    "Filter Freq", track=..., points=[[0, "200 Hz"], [32, "4 kHz"]], start=..., end=...)` - it
    plays through the range in real time (poll `action="status"`), then restores the transport.
    Arranging tools carry automation by default: `live_arrangement_from_scenes`,
    `live_arrangement_duplicate_clip` and `live_arrangement_copy_range` record the clip
    envelopes / copied lanes into the arrangement in the background (`automation` in the
    result; wait for `live_automation_record(action="status")` to say `finished`).
    Add `speed="fast"` for long ranges: the pass runs at a raised tempo (restored after; ~5x
    faster with a LiveBridge Engine in the set, which writes 50x a second) - not for the
    tempo itself or a song with tempo automation.
11. **Bounce / export** - `live_record_resample(start="1.1.1", bars=8, source="master")` records
    the section onto an audio track in real time (plays through the speakers; tell the user).
    Freeze a track: `live_record_resample(source="Bass", channel="Post FX")`.
12. **Save** - Live's API cannot save: ask the user to press **Cmd/Ctrl+S**.

A multi-step build can go through `live_command_batch` (one undo step, no rollback - steps before
a failure stay; next-tick state such as the playhead reads stale inside the batch).

## 4b. Check your work: theory and ears

- **`live_theory_analyze`** (MIDI, instant): `clips=[{"track":"Bass","slot":0},
  {"track":"Pad","slot":0}, {"track":"Lead","slot":0}]` -> key (+ runner-up), chord names with
  Roman numerals, `progression` (paste-able into `live_clip_write_chords`), `out_of_key` notes,
  `clashes` between parts (`semitone` rubs, `low_mud`) and suggestions. Use it **before** adding
  to the user's material (which key? which chords?) and **after** writing parts that play
  together. Fix clashes with `live_clip_modify_notes` / `live_clip_transform_notes(fit_scale=
  true)`. Drum Rack clips are recognised and only get statistics.
- **`live_theory_melody`** (one melody clip, instant): the craft checklist for leads, hooks and
  toplines — off-grid starts, 3+ note lengths, rests, a velocity arc, one climax 60-75% through,
  a leap answered by a step, tension notes resolved by step (`harmony=[{"track": "Pad",
  "slot": 0}]`), a developed motif, question/answer; `mood="melancholy"` also checks contour,
  velocity and density. Run it before handing over a melody you wrote (`PRODUCTION.md` §11-12).
- **`live_audio_analyze`** (audio, ~1 s per minute of audio): `file_path=` or an audio clip
  (`track`+`slot`) -> LUFS, true peak, crest factor, 8-band spectral balance with plain-language
  `flags` (mud, harsh, no sub, wide low end, clipping), stereo correlation/width, tempo, key and
  the `energy` curve over time; `reference=` compares against a reference track. Uses:
  - *Hear the set*: `live_record_resample(...)` -> `clips[0].file_path` -> analyse (`kind="mix"`).
  - *Samples / Splice loops*: tempo + key before importing -> set warp/`pitch_coarse` to match.
  - *The user's reference track*: structure (`energy`), loudness and balance to aim for.
- **`live_audio_problems`** (a part, a sample, a bounce): clipping, DC offset, a flipped side,
  mains hum, noise floor and persistent resonances, each with the fix (resonances: an EQ Eight
  bell `eq` {frequency_hz, gain_db, q}). **`live_audio_align(a=..., b=...)`**: kick vs sub (or any
  two layers) — offset in ms/beats, polarity, and how much louder they sum aligned; `apply=true`
  flips B's polarity with a Utility. Workflow: `WORKFLOWS.md` §12.
  It needs the optional audio libraries (`type: "unsupported"` carries the pip command - relay
  it). It measures; the user's ears decide.
- **`live_engine_listen`** (real time, no bounce): when the optional LiveBridge Engine Max for
  Live device sits on the master (`live_engine_status` says so), listen while the song plays:
  `live_transport_play()` then `live_engine_listen(seconds=4)` -> momentary/short-term LUFS,
  peak, crest, band balance, correlation, `low_end_width` and the same `flags`. Right after
  playback, `live_engine_listen(history=True, seconds=30)` answers at once from the last minute.
  `track="all"` reads every device over the same window (track balance).
  - *A/B*: loop the section, `live_engine_listen(seconds=4, save_as="before")`, make the
    change, `live_engine_compare(before="before")` -> what changed, better/worse.
  - *Masking while playing*: with an Engine at the end of each track to check,
    `live_engine_masking(seconds=8)` (fader levels included, muted tracks skipped).
  - *Capture*: `live_engine_capture(seconds=8, tracks=["master"])` -> WAV paths for
    `live_audio_analyze` (tempo, key, energy), `live_audio_compare` or `live_sample_import`.
  - *Movement*: `live_engine_modulate(track="Bass", device="Auto Filter", parameter=
    "Frequency", shape="sine", rate="2 bars", depth=0.4)` sweeps a parameter in time with the
    song (also "1/8d", "1/16t", "0.5 Hz"; shapes triangle, saw, square, random,
    smooth_random, steps=[...]); nothing is written and `live_engine_unmodulate` puts the
    value back. Use it to audition movement; when the user likes it, write it as automation
    (`live_automation_*`) — modulations are not saved with the set. `mode="offset"` (Engine
    1.7+) swings around the knob like Live's own LFO and leaves the knob to the user (they can
    keep turning it while it moves); the default `"replace"` takes the knob over.
  - *What the user turns in a hosted plug-in* (LiveBridge Host): every round is
    reset → user tweaks → read. 1) `live_plugin_host_parameters(touched="reset")` **before**
    asking them to tweak — the log otherwise still holds earlier rounds and restore bursts
    (undo, a reopened set, a preset load); 2) they say "done"; 3) `touched=true` (or
    `touched="2 min"`). Report only `parameters`; `restores` are not the user's hands (Live
    re-announcing a whole state) — mention one only if it explains a changed sound. A
    `before` of null means LiveBridge never read that value. Native plug-ins (after a
    handover) are not watched: use `live_device_parameters` on the rack instead.
  - *Mix and master* — **one call, no devices to place**: run `live_mix_auto(genre=...,
    master="streaming", section_bars=[113, 128])` (or "club", "apple" ...) with `bars` the fullest
    section (the drop) — the tool loops it, plays it and stops again (without `section_bars` the song
    must already play there). It puts a LiveBridge Channel at the end of every track that makes sound (it
    replaces an Engine there) and an Engine on the master, sets each part's strip by role,
    balances the faders (level-neutral: only parts more than 3 dB off their role move, to just
    inside that, so a second run changes nothing; protect the lead with `protect=[...]`; the
    report lists every fader move with from/to, and per strip only the controls it changed,
    `before -> after`), then masters through the
    LiveBridge Master device before the master's Engine. Needs Max for Live (Max 9 for the
    Channel and Master). On the user's own mix: `apply=false` first (it then places nothing and
    only plans from the Channels already there) and show the plan; report the `reasons` after.
    A big set outlives the call: the answer is then `{job, status: "running", phase}` — the
    run goes on in Live; call `live_mix_job(job=<id>, wait_seconds=30)` until `status` is "done" and
    report its `result`. Never start another mix/master run meanwhile (it is refused as
    `busy`). Melodic house/techno or progressive: `genre="melodic_house"` (leads and pads stay
    close to the kick); one-shots and fills are left to the ear (`notes` says which). While a
    run listens it loops the bars that were playing (unless the user's own loop is on) and
    gives the loop back after — start it where the fullest section plays. Strip controls the
    user set by hand are kept on a rerun (`kept`); `keep_manual=false` resets them too. Muted
    tracks (mute automation) still get strips — their meter hears the part before the mute.
    Kick vs bass fixes are opt-in (`low_end=true`: Phase + Unmask devices on the bass). The
    report is a summary; `detail="full"` has every reading. A track's `measured` says what the
    compressor really did; the master's `missing_gain_db` says how much level the mix lacks.
  - *Sound check, balance, master step by step* (each tool places the meters it needs):
    `live_sound_check()` -> silent or strangled parts and filters shut below their role's
    floor, before you build on them; `live_mix_balance(genre=...)` sets the faders to role
    levels by measurement (kick on top ...) and says whether each band problem is a master or a
    track fix; `live_master_auto(destination="streaming"|"club"|...)` drives EQ Eight -> Glue ->
    Limiter (or one LiveBridge Master device: `chain="livebridge"`, Max 9) to the loudness
    target and stops before the punch collapses. Kick and bass cancelling each other: `live_mix_phase(track="Bass")` (polarity + all-pass
    rotation, measured on the master); fighting over a band: `live_mix_unmask(track="Bass",
    against="Kick")` (the bass's band dips only while the kick plays). `WORKFLOWS.md`
    §19-20. On the user's own mix, run `apply=false` first and show the plan.
  - *Follow actions / generative playback*: Live's API has none, the Engine plays them:
    `live_engine_follow(target="Drums", every="2 bars", actions={"next": 3, "other": 1},
    chance=0.8)` cycles clip variations; `target="scenes"` chains scenes. Stop with
    `live_engine_unfollow`. Needs launch quantization (1 bar is best) and a playing transport.
  - *What the user plays*: with the LiveBridge MIDI device on a MIDI track (before the
    instrument; the track armed or monitored), `live_midi_played(seconds=30, quantize="1/16")`
    returns what was just played as `live_clip_add_notes`-ready notes — "turn what I played
    into a clip", "harmonize that riff". `live_midi_play(notes=[...], start="next_bar")`
    auditions a phrase live without writing a clip; `live_midi_stop` ends it.
  No device yet -> add it yourself when the task needs it (say so in one line):
  `live_browser_load(query="LiveBridge Engine", category="audio_effect", track="master")` (or
  a track name; MIDI tracks need their instrument first), then `live_engine_status` until it
  is listed (~2 s); LiveBridge MIDI: `query="LiveBridge MIDI", category="midi_effect"` on the
  MIDI track. If the browser does not find it, Max for Live or the device is missing:
  tell the user, don't insist. Any other Max for Live device loads the same way
  (`category="audio_effect"|"midi_effect"|"instrument"`).

## 4c. Remember, keep sounds, generate, compare

- **Session memory**: after the user keeps or rejects something meaningful, write one short
  `live_memory_note(text=..., kind="decision")`; open threads ("the drop needs a counter-line")
  as `kind="idea"`, things about the user ("prefers dry drums") as `kind="preference"`. Notes
  file themselves under the open Live Set's name (`song.set_name` in `live_set_snapshot`). A set never
  saved (`unsaved_set: true`) has no name yet: suggest saving it, and once it is saved move the
  early notes with `live_memory_update(id=<one of them>, project="<set name>",
  whole_project=true)`. Mark ideas done with `live_memory_update(id=..., done=true)`. Don't note
  every small tweak.
- **Sound library**: Live's API cannot save presets, so keep sounds the user likes with
  `live_sound_save(name=..., track=..., device=<path>, tags=[...])` and recall them with
  `live_sound_load` (same device type). For Serum 2 this also survives a re-expose: save,
  `live_plugin_expose(...)` with more parameters, then `live_sound_load` on the new device
  path. `only=["filter"]` takes just part of a sound.
- **Generative**: `live_clip_write_euclid(rhythms={"kick": "4/16", "rim": "3/8+2", "perc":
  "5/16"}, bars=...)` for Euclidean rhythms and polymeters; `live_clip_note_chance(probability=
  [0.5, 0.9], pitch="F#1")` so hats and ghosts vary every loop (downbeats stay certain).
- **Masking and A/B**: bounce two or more parts over the same bars
  (`live_record_resample(source=<track>)` each) and run `live_audio_masking(sources=[...])` to
  see which bands they fight over; after a mix change, bounce again and run
  `live_audio_compare(before=..., after=...)` to show what improved and what got worse.

## 5. Instruments, effects, plug-ins, samples, parameters

- Built-in device, no preset needed: `live_device_insert(name="EQ Eight", track=...)` (12.3+).
- Presets/sounds from Live's library: `live_browser_load(query, category="instrument" |
  "audio_effect" | "midi_effect" | "drum_kit")`, or `live_browser_search` +
  `live_browser_load(uri=...)`; replace a device in place with `live_browser_hotswap`.
- **Serum 2 / big VST3 plug-ins**: a plain load exposes **0** parameters (Live only shows the
  device's Configure list). Use `live_plugin_expose(plugin="Serum 2",
  parameters=["sound_design"], new_track=true)` - 120 curated controls; add names/groups
  ("osc a", "filter", "env", "lfo", "fx", "macros"; max 128 per rack), wire macros with
  `macros={"1": "Filter 1 Freq"}`, start from a sound with
  `live_plugin_preset_files(plugin="Serum 2")` -> `preset_file=`. Then
  `live_device_set_parameters` / automation on the returned `device` path. Expose **first**, then
  design: re-exposing restarts the sound from the preset/template. `.SerumPreset` files cannot be
  embedded (load them in Serum's window: `live_plugin_set(editor_open=true)`). Other VST3s:
  `live_plugin_param_map(plugin=...)` once. Audio Units expose nothing this way - prefer VST3;
  for AU/VST2 ask the user to use the device's **Configure** button (`live_plugin_configure`
  lists the names and waits).
- **What plug-ins does the user own?** `live_plugin_search(query="reverb", kind="audio_effect")`
  lists every installed plug-in Live knows (not only those in the set); suggest only those.
- Plain plug-in load (no control needed): `live_browser_load("Serum 2", category="plugin",
  plugin_format="vst3", editor_open=false)`.
- Racks: `live_rack_macros` (read + set macros), `live_drumrack_overview`, `live_drumrack_set_pad`,
  `live_drumrack_convert` (pad <-> track), `live_simpler_action("to_drum_rack")` (slices to pads).
- **Find samples** the way Live's browser does (Library > Samples: Core Library, packs, User
  Library and the user's own folders, with Live's browser tags):
  `live_sample_search(tags=["Drums|Kick", "Character|Punchy"], kind="one_shot")` -> each result
  has an absolute `path` to load. Words go in `query` ("909 kick", "vinyl"); a bare tag
  ("Punchy") matches any group; `live_sample_tags(filter="punch")` shows which tags exist.
  Offer a few results (`order="random"` for variety, `order="most_used"` for the user's
  go-to sounds) unless the user said "any". "More like this one":
  `live_sample_search(similar_to=<path>, tags=[...])` ranks by Live's own audio features;
  `source="user_folder"` keeps to the user's own folders ("core_library", "pack",
  "user_library" too); `category="Bass"` uses Live's browser categories
  (`live_sample_tags(categories=true)` lists them). A whole kit in one call:
  `live_sample_search(kind="one_shot", limit=3, searches=[{"tags": ["Drums|Kick"]}, {"tags":
  ["Drums|Snare"]}, {"tags": ["Drums|Hihat"]}])`. `live_sample_duplicates` finds identical
  audio. A null `path`
  or `exists: false` -> `live_sample_index()` explains which folder is unknown.
  "Load a punchy kick onto C1": search, then `live_drumrack_set_pad(note="C1", track=...,
  file_path=<path>)`.
- Samples on disk: `live_sample_import(file_path, track, mode="session"|"arrangement"|"simpler")`,
  onto a pad with `note="C1"` (or `live_drumrack_set_pad(note, file_path=...)`); `.mid` files
  import as MIDI clips the same way. Paths are on the machine running Live; in LAN mode a file
  that only exists on Claude's machine is sent over automatically (`live_sample_upload` does it
  explicitly, also for URLs).
- Simpler: `live_simpler_get/set/action` (playback mode, warp, slices, crop, reverse,
  replace_sample).
- Non-parameter settings (Wavetable wavetables, Hybrid Reverb IR, EQ Eight modes, Looper):
  `live_device_properties` / `live_device_action`; the Wavetable modulation matrix:
  `live_device_modulation`.
- Audio -> MIDI (drums/harmony/melody) or audio -> Simpler: `live_clip_convert`.
- Save an A/B snapshot of a device: `live_device_set_state(save_to_compare_slot=true)`, compare
  with `compare_b`.

## 6. Splice

LiveBridge does not search Splice itself; the official Splice MCP (a separate server, usually named
`splice`) does. If its tools are missing, call `live_splice_setup_info` and relay the steps.
1. Search with the Splice tools (key, BPM, genre, instrument, loop vs one-shot); present a few
   options before downloading - **downloads cost the user's Splice credits** (max 100 / 24 h).
2. After downloading with the Splice MCP: `live_splice_import_downloaded(files=[<paths Splice
   reported>], track=..., mode="session"|"arrangement"|"simpler"|"drum_rack")` (files are sent to
   the Live machine automatically in LAN mode). Without paths use `newest=N,
   max_age_minutes=10`. `live_splice_watch_folder` is only for downloads the user makes by hand
   in the Splice app/browser.
3. Tidy up: `live_clip_set` (warp, gain, name), match tempo (`warping=true`), transpose with
   `pitch_coarse` if the key differs, fix hits with `live_clip_warp`. One-shots: `mode="simpler"`
   or onto a pad (`mode="drum_rack"`, `note=`).

## 7. Safety and etiquette

- **Ask before destructive actions** on the user's material: deleting tracks/scenes/clips that
  contain content, `replace=true`/`clear` on existing notes, overwriting a clip, randomising a
  device, deleting devices. Your own freshly created objects may be changed freely.
- Don't start or stop playback, arm tracks, record or resample unless asked (or clearly part of
  the task); say when you do. Keep volumes sane (nothing above 0 dB on the master).
- After a `type: "timeout"`, do **not** blindly repeat a mutating call - it may still have run;
  re-read the state first. `live_dialog_get` shows whether a Live dialog is open; answer it with
  `live_dialog_press(button, expect=...)` **only after the user said which button** (labels are
  not available - show the message and the button count).
- Undo is available: `live_transport_undo(steps=n)` (check the returned names; the user's own
  edits are on the same stack).
- **Not possible through Live's API**: saving the set, exporting files (bounce with
  `live_record_resample` instead), freeze/flatten, grouping or moving tracks, drawing arrangement
  automation lanes (record them with `live_automation_record`), menu commands, preferences. Say
  so plainly and ask the user to do it (e.g. "press Cmd/Ctrl+S to save"); remind them to save
  after substantial work.
- **Racks/devices the API cannot touch** (answer, don't try tools): mapping a parameter to a macro
  (user: right-click the knob -> *Map to Macro*; then you can drive the macro; plug-in macros:
  `live_plugin_expose(macros=...)`); deleting, duplicating or reordering rack chains (mute the
  chain instead; Drum Rack pads can be cleared or copied with `live_drumrack_set_pad`);
  key/velocity/chain-select zones; saving device/rack/plug-in presets (user: the device's save
  button; A/B slot: `save_to_compare_slot`); Sampler zones/samples (use Simpler:
  `live_sample_import(mode="simpler")`); the Drum Sampler's sample (hot-swap the pad with a
  sample: `live_browser_hotswap(drum_pad=...)` puts a Simpler there). Details:
  `docs/LIVE_API_NOTES.md` §12.
- **Things that fail silently** (no error, just no sound or the wrong sound): a track where a
  session clip was fired ignores its arrangement clips until 'Back to Arrangement'
  (`live_transport_set(back_to_arranger=false)`); automation overrides a value you set by hand
  (rewrite or clear the automation); a note on an empty Drum Rack pad plays nothing
  (`live_drumrack_overview`); editing a session clip does not update its arrangement copies;
  a low-pass far below a part's range leaves only its fundamental (`live_sound_check`). Track
  and device *indices* shift when anything is added or deleted — address by name, and delete
  from the highest index down.
- `live_lom_*` and `live_eval_python` are escape hatches for things no curated tool covers
  (`live_commands` lists what the installed Remote Script supports; `live_command_call` runs such
  a bridge command directly). Use `live_lom_describe` to explore first; `live_eval_python` only
  when necessary, never with destructive code.

## 8. Token economy

Use `detail="minimal"`, `filter=`, `limit`/`offset` on list tools (paged answers carry `total`,
`count` and `next_offset` while more follow); fetch notes only for the clip
you edit (`live_clip_get_notes`); don't re-snapshot the whole set after every small edit - only
after structural changes or when something is unexpected.

## 9. Errors

| `type` | Do this |
|---|---|
| `connection` | Live not reachable - see step 1. |
| `not_found` | Index/name moved - re-snapshot, use names/paths. A plug-in parameter "Live does not expose" -> `live_plugin_expose`. |
| `invalid_state` | Read the message (slot full, audio vs MIDI track, frozen track) and adapt. |
| `bad_args` | Fix the argument; the message lists valid values (and accepted argument names). |
| `unsupported` | This Live version/edition can't; use the alternative the message suggests (e.g. browser instead of `live_device_insert` before 12.3). |
| `timeout` | A dialog may be open in Live - `live_dialog_get`, ask the user; verify before retrying. |
| `forbidden` | `live_eval_python` is disabled (no token or `allow_eval: false`); use curated/LOM tools. |
Pliki w paczce (10)
  • GENRES.md 26 KB
  • MASSIVE.md 17 KB
  • OMNISPHERE.md 26 KB
  • PRODUCTION.md 24 KB
  • SERUM.md 24 KB
  • SERUM_PRESETS.md 37 KB
  • SKILL.md 36 KB
  • SURGE_XT.md 14 KB
  • THIRD_PARTY_NOTICES.md 9 KB
  • WORKFLOWS.md 48 KB

Wersje

W bazie nie ma innych skilli o nazwie livebridge.

Migawka bazy z 13.11.2026 · wersja paczki 9607e034fdb7 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 87ableton-live
    Podpowiada, jak tworzyć muzykę w Ableton Live 12 na macOS: dobiera wbudowane instrumenty i efekty, pracuje z klipami, warpingiem i automatyką.
  • 90Ableton Live Runner
    Przygotowuje i uruchamia projekt Extension SDK dla Ableton Live: konfigurację, ściągę API, szkielet rozszerzenia i sposób uruchamiania innych skilli Ableton.
  • 100ableton-stem-export
    Eksportuje z projektu Ableton Live 12 czytelny pakiet stemów z nazwami, BPM, tonacją i plikiem README.
  • 100livepilot-mixing
    Wykonuje operacje miksowania w Ableton Live: balans poziomów, głośność, panoramę, EQ, kompresję, wysyłki, routing, gain staging i sidechain.
  • 100livepilot-devices
    Przeszukuje, ładuje i konfiguruje urządzenia w Ableton Live: efekty, instrumenty, syntezatory, racki i presety, z ustawieniem łańcucha urządzeń do projektowania dźwięku.
  • 90Ableton Genre Cover
    Buduje wielościeżkowy aranż znanej melodii w docelowym gatunku w Ableton Live: perkusję, bas, akordy, pad i lead z dobranymi efektami.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.