livepilot 1.7.1 → 1.7.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (6) hide show
  1. package/README.md +336 -335
  2. package/mcp_server/tools/_theory_engine.py +2 -2
  3. package/package.json +2 -2
  4. package/plugin/plugin.json +2 -2
  5. package/plugin/skills/livepilot-core/SKILL.md +4 -4
  6. package/plugin/skills/livepilot-core/references/overview.md +2 -2
package/README.md CHANGED
@@ -7,175 +7,162 @@
7
7
  ╚══════╝╚═╝ ╚═══╝ ╚══════╝╚═╝ ╚═╝╚══════╝ ╚═════╝ ╚═╝
8
8
  ```
9
9
 
10
- [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
11
- [![CI](https://github.com/dreamrec/LivePilot/actions/workflows/ci.yml/badge.svg)](https://github.com/dreamrec/LivePilot/actions/workflows/ci.yml)
12
- [![GitHub stars](https://img.shields.io/github/stars/dreamrec/LivePilot)](https://github.com/dreamrec/LivePilot/stargazers)
13
- [![npm](https://img.shields.io/npm/v/livepilot)](https://www.npmjs.com/package/livepilot)
10
+ An agentic production system for Ableton Live 12.
11
+ 155 tools. Device atlas. Spectral perception. Technique memory.
12
+ Neo-Riemannian harmony. Euclidean rhythm. Species counterpoint.
13
+ It doesn't assist — it produces.
14
14
 
15
- **AI copilot for Ableton Live 12** — 155 MCP tools, a deep device knowledge corpus, real-time audio analysis, generative algorithms, neo-Riemannian harmony, MIDI file I/O, and persistent technique memory.
15
+ ---
16
16
 
17
- Most Ableton MCP servers give the AI tools to push buttons. LivePilot gives it three things on top of that:
17
+ ## Architecture
18
18
 
19
- - **Knowledge** — A device atlas of 280+ instruments, 139 drum kits, and 350+ impulse responses. The AI doesn't guess device names or parameters. It looks them up.
20
- - **Perception** — An M4L analyzer that reads the master bus in real-time: 8-band spectrum, RMS/peak metering, pitch tracking, key detection. The AI makes decisions based on what it hears, not just what's configured.
21
- - **Memory** — A technique library that persists across sessions. The AI remembers how you built that bass sound, what swing you like on hi-hats, which reverb chain worked on vocals. It learns your taste over time.
19
+ ```
20
+ ┌─────────────────────────────────────────────────────────┐
21
+ │ │
22
+ │ KNOWLEDGE PERCEPTION MEMORY │
23
+ │ ─────────── ────────── ────── │
24
+ │ 280+ devices 8-band FFT recall by │
25
+ │ 139 drum kits RMS / peak mood, genre, │
26
+ │ 350+ impulse pitch tracking texture │
27
+ │ responses key detection │
28
+ │ │
29
+ │ ┌────────────┐ ┌────────────┐ ┌────────────┐ │
30
+ │ │ Device │───▶│ M4L │───▶│ Technique │ │
31
+ │ │ Atlas │ │ Analyzer │ │ Store │ │
32
+ │ └─────┬──────┘ └─────┬──────┘ └─────┬──────┘ │
33
+ │ └─────────────────┼─────────────────┘ │
34
+ │ ▼ │
35
+ │ ┌─────────────────┐ │
36
+ │ │ 155 MCP Tools │ │
37
+ │ │ 16 domains │ │
38
+ │ └────────┬────────┘ │
39
+ │ │ │
40
+ │ Remote Script ──┤── TCP 9878 │
41
+ │ M4L Bridge ─────┤── UDP 9880 / OSC 9881 │
42
+ │ │ │
43
+ │ ┌────────────────┐ │
44
+ │ │ Ableton Live │ │
45
+ │ └────────────────┘ │
46
+ └─────────────────────────────────────────────────────────┘
47
+ ```
22
48
 
23
- These three layers sit on top of 155 deterministic MCP tools that cover transport, tracks, clips, MIDI, devices, scenes, mixing, browser, arrangement, sample manipulation, generative algorithms, neo-Riemannian harmony, and MIDI file I/O. Every command goes through Ableton's official Live Object Model API — the same interface Ableton's own control surfaces use. Everything is reversible with undo.
49
+ The atlas gives the AI knowledge of every device in Ableton's library — real names, real URIs, real parameters. The analyzer gives it ears — spectral data from the master bus via a Max for Live device. The memory gives it history — a searchable library of production decisions that persists across sessions. All three feed into 155 deterministic tools that execute on Ableton's main thread through the official Live Object Model API. Everything is reversible with undo.
24
50
 
25
51
  ---
26
52
 
27
- ## The Three Layers
53
+ ## Tools
28
54
 
29
- Most MCP servers are a flat list of tools. LivePilot is a production system with three layers that work together.
55
+ ### CORE ─────────────────────────────────────────
30
56
 
31
- ### 1. Device Atlas — What the AI knows
57
+ The foundation. Session control, MIDI, device management, mixing. Every tool maps directly to an LOM call — no abstraction, no guessing.
32
58
 
33
- A structured knowledge corpus of 280+ Ableton devices, 139 drum kits, and 350+ impulse responses. When the AI needs to load an instrument, it doesn't hallucinate a name and hope for the best. It consults the atlas, finds the exact preset, and loads it by URI.
59
+ | Domain | # | Scope |
60
+ |--------|:-:|-------|
61
+ | Transport | 12 | playback, tempo, time sig, loop, metronome, undo/redo, cue points, diagnostics |
62
+ | Tracks | 14 | create MIDI/audio/return, delete, duplicate, arm, mute, solo, color, routing, monitoring |
63
+ | Clips | 11 | create, delete, duplicate, fire, stop, loop, launch mode, warp mode, quantize |
64
+ | Notes | 8 | add/get/remove/modify MIDI notes, transpose, duplicate, per-note probability |
65
+ | Devices | 12 | load by name or URI, get/set parameters, batch edit, racks, chains, presets, toggle |
66
+ | Scenes | 8 | create, delete, duplicate, fire, name, color, per-scene tempo |
67
+ | Browser | 4 | search library, browse tree, load items, filter by category |
68
+ | Mixing | 11 | volume, pan, sends, routing, meters, return tracks, master, full mix snapshot |
34
69
 
35
- The atlas is organized by category (synths, drums, effects, samples) with metadata about each device: what it sounds like, what parameters matter, what presets are available. When you say "load something warm and analog", the AI can search the atlas for instruments tagged with those qualities and pick one that actually exists in your library.
70
+ ### PERCEPTION ───────────────────────────────────
36
71
 
37
- This is the difference between an AI that says "I'll load Warm Analog Pad" (and crashes because it doesn't exist) and one that searches the drum kit index, finds "Kit-606 Tape.adg", and loads it by its real browser URI.
72
+ The M4L Analyzer sits on the master track. UDP 9880 carries spectral data from Max to the server. OSC 9881 sends commands back. All 135 core tools work without it — the analyzer adds 20 more and closes the feedback loop.
38
73
 
39
- ### 2. Analyzer — What the AI hears
74
+ **Spectral Analysis (3)** — 8-band frequency decomposition (sub → air), true RMS/peak metering, Krumhansl-Schmuckler key detection on accumulated pitch data.
40
75
 
41
- The LivePilot Analyzer is an M4L device that sits on the master track and feeds real-time audio data back to the AI:
76
+ **Deep LOM Access (4)** — hidden parameters not in the ControlSurface API, automation state for every parameter, recursive device tree walking (6 levels into nested racks), human-readable display values as shown in Live's UI.
42
77
 
43
- - **8-band spectrum** — sub, low, low-mid, mid, high-mid, high, presence, air
44
- - **RMS and peak metering** — true loudness, not just parameter values
45
- - **Pitch tracking and key detection** — Krumhansl-Schmuckler algorithm on accumulated pitch data
78
+ **Simpler Operations (7)** — replace/load samples, get slice points, crop, reverse, warp to N beats, get audio file paths on disk.
46
79
 
47
- This means the AI can verify its own work. After adding an EQ cut at 400 Hz, it reads the spectrum to confirm the cut actually reduced the mud. After loading a bass preset, it checks that the low end is present. Before writing a bass line, it detects the key of what's already playing.
80
+ **Warp Markers (4)** — get/add/move/remove. Tempo manipulation at the sample level.
48
81
 
49
- Without the analyzer, the AI is working blind — it can set parameters but can't hear the result. With it, the AI closes the feedback loop.
82
+ **Clip Preview (2)** — scrub at beat position, stop scrub.
50
83
 
51
- ### 3. Technique Memory — What the AI learns
84
+ ### INTELLIGENCE ─────────────────────────────────
52
85
 
53
- The memory system (`memory_learn` / `memory_recall` / `memory_replay`) stores production decisions as structured, searchable, replayable data. Not just parameter snapshots — the full context: what genre, what mood, what made it work, what the signal chain was, what MIDI pattern drove it.
86
+ #### Theory — 7 tools
54
87
 
55
- Five technique types: `beat_pattern`, `device_chain`, `mix_template`, `preference`, `browser_pin`. Each stores three layers of data:
88
+ Krumhansl-Schmuckler key detection with 7 mode profiles (major, minor, dorian, phrygian, lydian, mixolydian, locrian). Roman numeral analysis via scale-degree chord matching on a 1/32 note quantization grid. Voice leading checks — parallel fifths, parallel octaves, voice crossing, unresolved dominants. Species counterpoint generation (1st and 2nd species). SATB harmonization with smooth voice leading. Diatonic transposition that preserves scale relationships.
56
89
 
57
- | Layer | Contents | Purpose |
58
- |-------|----------|---------|
59
- | **Identity** | UUID, name, type, tags, timestamps, rating | Indexing and filtering |
60
- | **Qualities** | Mood, genre, rhythm feel, harmonic character, sonic texture, production notes | Search ranking and creative context |
61
- | **Payload** | Raw MIDI notes, device params, tempo, kit URIs, send levels | Exact replay or adaptation |
90
+ `analyze_harmony` · `suggest_next_chord` · `detect_theory_issues` · `identify_scale` · `harmonize_melody` · `generate_countermelody` · `transpose_smart`
62
91
 
63
- The agent consults memory by default before creative decisions. `memory_recall(query="dark heavy 808")` matches against mood, genre, and texture — not just names. The results inform the AI's choices without constraining them. Say "ignore my history" and it works from a clean slate. Say "use that boom bap beat from last session" and it pulls the exact technique and replays it.
92
+ #### Harmony — 4 tools
64
93
 
65
- Over time, the library becomes a structured representation of your production taste: swing ranges, kit preferences, harmonic tendencies, arrangement density. The AI reads across this at decision time. New output is always generated; the memory shapes the generation.
94
+ Neo-Riemannian PRL transforms on the Tonnetz. P flips the third: Cm ↔ C. L shifts by semitone: C ↔ Em. R by whole tone: C ↔ Am. All three are involutions — apply twice, return to origin. BFS through PRL space finds the shortest voice-leading path between any two triads. Cm to E major? That's PLP — the hexatonic pole. Three steps, each moving one voice by a semitone. The Hitchcock chord change.
66
95
 
67
- ### How the layers combine
96
+ Chromatic mediants for film-score harmony: chords a major/minor third away sharing 0-1 common tones. Maximum color shift, minimal voice movement.
68
97
 
69
- "Make a boom bap beat at 86 BPM" triggers the full stack:
98
+ `navigate_tonnetz` · `find_voice_leading_path` · `classify_progression` · `suggest_chromatic_mediants`
70
99
 
71
- 1. **Atlas** — finds the right drum kit (not a guess, a real preset with real samples)
72
- 2. **Memory** — recalls your previous boom bap patterns, checks your preferred swing amount and velocity curves
73
- 3. **Tools** — creates tracks, loads instruments, programs MIDI, chains effects, sets levels
74
- 4. **Analyzer** — reads the spectrum to verify the kick sits right, detects the key for the bass line, checks RMS to balance levels
100
+ #### Generative — 5 tools
75
101
 
76
- No other Ableton MCP server does this. Others have tools. LivePilot has tools + knowledge + perception + memory.
102
+ Bjorklund distributes N pulses across M steps — Bresenham's line algorithm applied to rhythm. E(3,8) = tresillo. E(5,8) = cinquillo. E(7,16) = Brazilian necklace. Layer multiple Euclidean patterns at different pitches for polyrhythmic textures.
77
103
 
78
- ---
104
+ Tintinnabuli (Arvo Pärt): for each melody note, find the nearest tone of a specified triad — above, below, or nearest. The T-voice gravitates toward the triad while the M-voice moves stepwise. Two voices, one rule, infinite music.
79
105
 
80
- ## Automation Intelligence
106
+ Phase shifting (Steve Reich): identical voices with accumulating timing drift. Voice 0 plays straight. Each subsequent voice shifts by N beats per repetition. They start in unison, gradually separate, and eventually realign.
81
107
 
82
- Most DAW integrations let the AI set a parameter to a value. LivePilot lets the AI write **automation curves** — envelopes that evolve parameters over time inside clips. This is the difference between a static mix and a living one.
108
+ Additive process (Philip Glass): melody unfolds note by note. Forward: 1, then 1-2, then 1-2-3. Backward: full melody, then remove from front. Both: forward then backward. The structure *is* the composition.
83
109
 
84
- ### The Curve Engine
110
+ `generate_euclidean_rhythm` · `layer_euclidean_rhythms` · `generate_tintinnabuli` · `generate_phase_shift` · `generate_additive_process`
85
111
 
86
- 16 mathematically precise curve types, organized in 4 categories:
112
+ #### Automation — 8 tools
87
113
 
88
- | Category | Curves | What they do |
89
- |----------|--------|-------------|
90
- | **Basic Waveforms** | `linear` · `exponential` · `logarithmic` · `s_curve` · `sine` · `sawtooth` · `spike` · `square` · `steps` | The building blocks. Exponential for filter sweeps (perceptually even). Logarithmic for volume fades (matches the ear). Spike for dub throws. Sawtooth for sidechain pumps. |
91
- | **Organic / Natural** | `perlin` · `brownian` · `spring` | What makes automation feel alive. Perlin noise for drifting textures. Brownian for analog-style parameter wander. Spring for realistic knob movements with overshoot and settle. |
92
- | **Shape Control** | `bezier` · `easing` | Precision curves for intentional design. Bezier with arbitrary control points. 8 easing types from the animation world: bounce, elastic, back overshoot, ease in/out. |
93
- | **Algorithmic** | `euclidean` · `stochastic` | Generative intelligence. Euclidean distributes automation events using the Bjorklund algorithm (the same math behind Euclidean rhythms). Stochastic applies Xenakis-inspired controlled randomness within narrowing bounds. |
114
+ 16 curve types in 4 categories:
94
115
 
95
- Every curve generates normalized points (0.0–1.0) that map to any parameter in Ableton — volume, pan, sends, device parameters, anything with an envelope.
116
+ ```
117
+ BASIC ─────── linear · exponential · logarithmic · s_curve
118
+ sine · sawtooth · spike · square · steps
119
+ ORGANIC ───── perlin · brownian · spring
120
+ SHAPE ─────── bezier · easing (8 types: bounce, elastic, back...)
121
+ GENERATIVE ── euclidean · stochastic
122
+ ```
96
123
 
97
- ### 15 Production Recipes
124
+ 15 built-in recipes: `filter_sweep_up` · `filter_sweep_down` · `dub_throw` · `tape_stop` · `build_rise` · `sidechain_pump` · `fade_in` · `fade_out` · `tremolo` · `auto_pan` · `stutter` · `breathing` · `washout` · `vinyl_crackle` · `stereo_narrow`
98
125
 
99
- Named presets for common techniques. One tool call instead of manual point calculation:
126
+ Perception-action loop: `analyze_for_automation` reads the spectrum and device chain, suggests what to automate, and maps each suggestion to a recipe. The AI doesn't write automation blind — it knows what to automate based on what it hears.
100
127
 
101
- | Recipe | Curve | What it does |
102
- |--------|-------|-------------|
103
- | `filter_sweep_up` | exponential | LP filter opening over 8-32 bars |
104
- | `filter_sweep_down` | logarithmic | LP filter closing, mirrors the sweep up |
105
- | `dub_throw` | spike | Instant send spike for reverb/delay throws |
106
- | `tape_stop` | exponential | Pitch dropping to zero — steep deceleration |
107
- | `build_rise` | exponential | Tension build on HP filter + volume + reverb |
108
- | `sidechain_pump` | sawtooth | Volume ducking per beat — fast duck, slow recovery |
109
- | `fade_in` / `fade_out` | log / exp | Perceptually smooth volume fades |
110
- | `tremolo` | sine | Periodic volume oscillation |
111
- | `auto_pan` | sine | Stereo movement via pan |
112
- | `stutter` | square | Rapid on/off gating |
113
- | `breathing` | sine | Subtle filter movement — acoustic instrument feel |
114
- | `washout` | exponential | Reverb/delay feedback increasing to wash |
115
- | `vinyl_crackle` | sine | Slow bit reduction for lo-fi character |
116
- | `stereo_narrow` | exponential | Collapse stereo to mono before drop |
128
+ `get_clip_automation` · `set_clip_automation` · `clear_clip_automation` · `apply_automation_shape` · `apply_automation_recipe` · `get_automation_recipes` · `generate_automation_curve` · `analyze_for_automation`
117
129
 
118
- ### The Feedback Loop
130
+ ### MEMORY + I/O ──────────────────────────────────
119
131
 
120
- `analyze_for_automation` reads the spectrum and device chain, then suggests what to automate:
132
+ #### Memory — 8 tools
121
133
 
122
- 1. **Reads the spectrum** — identifies frequency balance, sub content, dynamic range
123
- 2. **Scans the device chain** — detects filters, reverbs, synths, distortion
124
- 3. **Suggests automation targets** — "Filter detected → automate cutoff for movement", "Heavy sub content → HP filter sweep for builds"
125
- 4. **Recommends recipes** — maps each suggestion to the right named recipe
134
+ Persistent technique library. Five types: `beat_pattern`, `device_chain`, `mix_template`, `preference`, `browser_pin`. Each stores identity (name, tags, timestamps), qualities (mood, genre, texture, production notes), and payload (raw MIDI, device params, tempo, URIs). Recall by text query matching mood, genre, texture — not just names. Favorite, rate, replay.
126
135
 
127
- The AI doesn't just write automation — it knows what to automate based on what it hears.
136
+ `memory_learn` · `memory_recall` · `memory_list` · `memory_get` · `memory_update` · `memory_delete` · `memory_favorite` · `memory_replay`
128
137
 
129
- ---
138
+ #### MIDI I/O — 4 tools
130
139
 
131
- ## What You Can Do
140
+ Export session clips to standard .mid files. Import .mid into session clips — auto-creates the clip, tempo-aware timing conversion. Offline analysis without Ableton: note count, duration, tempo, pitch range, velocity stats, density curve, key estimate. Piano roll extraction: 2D velocity matrix at configurable resolution (default 1/32 note). Dependencies lazy-loaded — graceful error if missing.
132
141
 
133
- - **Produce** — Create tracks, load instruments from the atlas, program drum patterns, bass lines, chord progressions, and melodies — informed by your saved techniques
134
- - **Arrange** — Build full song structures in arrangement view with MIDI editing, cue points, automation, and timeline navigation
135
- - **Design sounds** — Browse Ableton's library, load presets, tweak every device parameter, chain effects, walk nested racks 6 levels deep
136
- - **Mix with ears** — Set levels, panning, sends, and routing. Read the spectrum, check RMS, detect the key. The analyzer tells the AI what changed, not just what was set
137
- - **Automate intelligently** — Write clip automation with 16 mathematically precise curve types, apply named recipes (dub throws, filter sweeps, sidechain pumps), get spectral-aware suggestions for what to automate next
138
- - **Remember and evolve** — Save techniques, build a personal style library, replay past decisions exactly or as variations
139
- - **Chop samples** — Load audio into Simpler, slice, reverse, crop, warp, and reprogram — all from conversation
140
- - **Iterate fast** — Transpose, humanize, quantize, duplicate, and reshape patterns through conversation
142
+ `export_clip_midi` · `import_midi_to_clip` · `analyze_midi_file` · `extract_piano_roll`
141
143
 
142
144
  ---
143
145
 
144
- ## Quick Start
146
+ ## Install
145
147
 
146
- ### 1. Install the Remote Script
148
+ ### 1. Remote Script
147
149
 
148
150
  ```bash
149
- npx -y github:dreamrec/LivePilot --install
151
+ npx livepilot --install
150
152
  ```
151
153
 
152
- ### 2. Enable in Ableton
154
+ Restart Ableton → Preferences → Link, Tempo & MIDI → Control Surface → **LivePilot**
153
155
 
154
- Restart Ableton Live, then go to **Preferences > Link, Tempo & MIDI > Control Surface** and select **LivePilot**.
155
-
156
- ### 3. Add to your MCP client
156
+ ### 2. MCP Client
157
157
 
158
158
  <details open>
159
159
  <summary><strong>Claude Code</strong></summary>
160
160
 
161
161
  ```bash
162
- claude mcp add LivePilot -- npx -y github:dreamrec/LivePilot
163
- ```
164
-
165
- Or add to `.mcp.json`:
166
-
167
- ```json
168
- {
169
- "mcpServers": {
170
- "LivePilot": {
171
- "command": "npx",
172
- "args": ["-y", "github:dreamrec/LivePilot"]
173
- }
174
- }
175
- }
162
+ claude mcp add LivePilot -- npx livepilot
176
163
  ```
177
164
 
178
- **Optional:** Install the Claude Code plugin for skills, slash commands, and the producer agent:
165
+ Plugin (adds skills, slash commands, producer agent):
179
166
 
180
167
  ```bash
181
168
  claude plugin add github:dreamrec/LivePilot/plugin
@@ -186,34 +173,30 @@ claude plugin add github:dreamrec/LivePilot/plugin
186
173
  <details>
187
174
  <summary><strong>Claude Desktop (macOS)</strong></summary>
188
175
 
189
- Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
176
+ `~/Library/Application Support/Claude/claude_desktop_config.json`:
190
177
 
191
178
  ```json
192
179
  {
193
180
  "mcpServers": {
194
181
  "LivePilot": {
195
182
  "command": "npx",
196
- "args": ["-y", "github:dreamrec/LivePilot"]
183
+ "args": ["livepilot"]
197
184
  }
198
185
  }
199
186
  }
200
187
  ```
201
188
 
202
- Restart Claude Desktop after saving.
203
-
204
189
  </details>
205
190
 
206
191
  <details>
207
192
  <summary><strong>Claude Desktop (Windows)</strong></summary>
208
193
 
209
- On Windows, `npx` can cause EBUSY file-locking errors. Install globally instead:
210
-
211
194
  ```cmd
212
- npm install -g github:dreamrec/LivePilot
195
+ npm install -g livepilot
213
196
  livepilot --install
214
197
  ```
215
198
 
216
- Add to `%APPDATA%\Claude\claude_desktop_config.json`:
199
+ `%APPDATA%\Claude\claude_desktop_config.json`:
217
200
 
218
201
  ```json
219
202
  {
@@ -225,26 +208,19 @@ Add to `%APPDATA%\Claude\claude_desktop_config.json`:
225
208
  }
226
209
  ```
227
210
 
228
- Restart Claude Desktop after saving.
229
-
230
211
  </details>
231
212
 
232
213
  <details>
233
214
  <summary><strong>Cursor</strong></summary>
234
215
 
235
- Open Cursor Settings > MCP Servers > Add Server, then use:
236
-
237
- - **Name:** LivePilot
238
- - **Command:** `npx -y github:dreamrec/LivePilot`
239
-
240
- Or add to `.cursor/mcp.json`:
216
+ `.cursor/mcp.json`:
241
217
 
242
218
  ```json
243
219
  {
244
220
  "mcpServers": {
245
221
  "LivePilot": {
246
222
  "command": "npx",
247
- "args": ["-y", "github:dreamrec/LivePilot"]
223
+ "args": ["livepilot"]
248
224
  }
249
225
  }
250
226
  }
@@ -253,34 +229,29 @@ Or add to `.cursor/mcp.json`:
253
229
  </details>
254
230
 
255
231
  <details>
256
- <summary><strong>VS Code (Copilot)</strong></summary>
232
+ <summary><strong>VS Code / Windsurf</strong></summary>
257
233
 
258
- Add to `.vscode/mcp.json`:
234
+ VS Code — `.vscode/mcp.json`:
259
235
 
260
236
  ```json
261
237
  {
262
238
  "servers": {
263
239
  "LivePilot": {
264
240
  "command": "npx",
265
- "args": ["-y", "github:dreamrec/LivePilot"]
241
+ "args": ["livepilot"]
266
242
  }
267
243
  }
268
244
  }
269
245
  ```
270
246
 
271
- </details>
272
-
273
- <details>
274
- <summary><strong>Windsurf</strong></summary>
275
-
276
- Add to `~/.codeium/windsurf/mcp_config.json`:
247
+ Windsurf — `~/.codeium/windsurf/mcp_config.json`:
277
248
 
278
249
  ```json
279
250
  {
280
251
  "mcpServers": {
281
252
  "LivePilot": {
282
253
  "command": "npx",
283
- "args": ["-y", "github:dreamrec/LivePilot"]
254
+ "args": ["livepilot"]
284
255
  }
285
256
  }
286
257
  }
@@ -288,236 +259,273 @@ Add to `~/.codeium/windsurf/mcp_config.json`:
288
259
 
289
260
  </details>
290
261
 
291
- ### 4. Verify connection
262
+ ### 3. M4L Analyzer (optional)
263
+
264
+ Drag `LivePilot_Analyzer.amxd` onto the master track. Unlocks 20 additional tools: spectral analysis, key detection, sample manipulation, deep device introspection. All core tools work without it.
265
+
266
+ ### 4. Verify
292
267
 
293
268
  ```bash
294
- npx -y github:dreamrec/LivePilot --status
269
+ npx livepilot --status
295
270
  ```
296
271
 
297
272
  ---
298
273
 
299
- ## 155 Tools Across 16 Domains
300
-
301
- | Domain | Tools | What you can do |
302
- |--------|:-----:|-----------------|
303
- | **Transport** | 12 | Play/stop, tempo, time signature, loop, undo/redo, metronome, diagnostics |
304
- | **Tracks** | 14 | Create MIDI/audio/return tracks, name, color, mute, solo, arm, group fold, input monitoring |
305
- | **Clips** | 11 | Create, delete, duplicate, fire, stop, loop settings, launch mode, warp mode |
306
- | **Notes** | 8 | Add/get/remove/modify MIDI notes, transpose, quantize, duplicate |
307
- | **Devices** | 12 | Load instruments & effects, tweak parameters, rack chains, presets — works on regular, return, and master tracks |
308
- | **Scenes** | 8 | Create, delete, duplicate, fire, rename, color, per-scene tempo |
309
- | **Mixing** | 11 | Volume, pan, sends, routing, meters, mix snapshot — return tracks and master fully supported |
310
- | **Browser** | 4 | Search Ableton's library, browse categories, load presets |
311
- | **Arrangement** | 19 | Create clips, full MIDI note CRUD, cue points, recording, automation |
312
- | **Automation** | 8 | Clip envelope CRUD, 16-type curve engine, 15 named recipes, spectral-aware suggestions |
313
- | **Memory** | 8 | Save, recall, replay, and manage production techniques |
314
- | **Analyzer** | 20 | Real-time spectral analysis, key detection, sample manipulation, warp markers, device introspection (requires M4L device) |
315
- | **Theory** | 7 | Harmony analysis, Roman numerals, scale identification, chord suggestions, countermelody, SATB harmonization, smart transposition |
316
- | **Generative** | 5 | Euclidean rhythms (Bjorklund), polyrhythmic layering, Pärt tintinnabuli, Reich phase shift, Glass additive process |
317
- | **Harmony** | 4 | Tonnetz navigation, voice leading paths, neo-Riemannian classification, chromatic mediants |
318
- | **MIDI I/O** | 4 | Export clips to .mid, import .mid files, offline MIDI analysis, piano roll extraction |
274
+ ## Plugin
319
275
 
320
- <details>
321
- <summary><strong>Full tool list</strong></summary>
276
+ ```bash
277
+ claude plugin add github:dreamrec/LivePilot/plugin
278
+ ```
279
+
280
+ | Command | What |
281
+ |---------|------|
282
+ | `/session` | Full session overview with diagnostics |
283
+ | `/beat` | Guided beat creation |
284
+ | `/mix` | Mixing assistant |
285
+ | `/sounddesign` | Sound design workflow |
286
+ | `/memory` | Technique library management |
287
+
288
+ **Producer Agent** — autonomous multi-step production. Consults memory for style context, searches the atlas for instruments, creates tracks, programs MIDI, chains effects, reads the spectrum to verify. Ships with a reference corpus (drum patterns, chord voicings, sound design recipes, mixing templates).
289
+
290
+ **Core Skill** — operational discipline connecting all three layers. Consult atlas before loading. Read analyzer after mixing. Check memory before creative decisions. Verify every mutation.
291
+
292
+ ---
293
+
294
+ ## Full Tool List ────────────────────────────────
295
+
296
+ 155 tools across 16 domains.
322
297
 
323
298
  ### Transport (12)
324
- `get_session_info` · `set_tempo` · `set_time_signature` · `start_playback` · `stop_playback` · `continue_playback` · `toggle_metronome` · `set_session_loop` · `undo` · `redo` · `get_recent_actions` · `get_session_diagnostics`
299
+ | Tool | Description |
300
+ |------|-------------|
301
+ | `get_session_info` | Session state: tempo, tracks, scenes, transport |
302
+ | `set_tempo` | Set tempo (20-999 BPM) |
303
+ | `set_time_signature` | Set time signature |
304
+ | `start_playback` | Start from beginning |
305
+ | `stop_playback` | Stop |
306
+ | `continue_playback` | Resume from current position |
307
+ | `toggle_metronome` | Enable/disable click |
308
+ | `set_session_loop` | Set loop start, length, on/off |
309
+ | `undo` | Undo last action |
310
+ | `redo` | Redo |
311
+ | `get_recent_actions` | Recent undo history |
312
+ | `get_session_diagnostics` | Analyze session for issues |
325
313
 
326
314
  ### Tracks (14)
327
- `get_track_info` · `create_midi_track` · `create_audio_track` · `create_return_track` · `delete_track` · `duplicate_track` · `set_track_name` · `set_track_color` · `set_track_mute` · `set_track_solo` · `set_track_arm` · `stop_track_clips` · `set_group_fold` · `set_track_input_monitoring`
315
+ | Tool | Description |
316
+ |------|-------------|
317
+ | `get_track_info` | Track details: clips, devices, mixer |
318
+ | `create_midi_track` | New MIDI track |
319
+ | `create_audio_track` | New audio track |
320
+ | `create_return_track` | New return track |
321
+ | `delete_track` | Delete a track |
322
+ | `duplicate_track` | Copy track with all content |
323
+ | `set_track_name` | Rename |
324
+ | `set_track_color` | Set color (0-69) |
325
+ | `set_track_mute` | Mute on/off |
326
+ | `set_track_solo` | Solo on/off |
327
+ | `set_track_arm` | Arm for recording |
328
+ | `stop_track_clips` | Stop all clips on track |
329
+ | `set_group_fold` | Fold/unfold group track |
330
+ | `set_track_input_monitoring` | Set monitoring mode |
328
331
 
329
332
  ### Clips (11)
330
- `get_clip_info` · `create_clip` · `delete_clip` · `duplicate_clip` · `fire_clip` · `stop_clip` · `set_clip_name` · `set_clip_color` · `set_clip_loop` · `set_clip_launch` · `set_clip_warp_mode`
333
+ | Tool | Description |
334
+ |------|-------------|
335
+ | `get_clip_info` | Clip details: length, loop, launch |
336
+ | `create_clip` | New empty MIDI clip |
337
+ | `delete_clip` | Delete a clip |
338
+ | `duplicate_clip` | Copy to another slot |
339
+ | `fire_clip` | Launch a clip |
340
+ | `stop_clip` | Stop a clip |
341
+ | `set_clip_name` | Rename |
342
+ | `set_clip_color` | Set color |
343
+ | `set_clip_loop` | Loop start, end, on/off |
344
+ | `set_clip_launch` | Launch mode and quantization |
345
+ | `set_clip_warp_mode` | Set warp algorithm |
331
346
 
332
347
  ### Notes (8)
333
- `add_notes` · `get_notes` · `remove_notes` · `remove_notes_by_id` · `modify_notes` · `duplicate_notes` · `transpose_notes` · `quantize_clip`
348
+ | Tool | Description |
349
+ |------|-------------|
350
+ | `add_notes` | Add MIDI notes with velocity, probability |
351
+ | `get_notes` | Read notes from a region |
352
+ | `remove_notes` | Remove notes in a region |
353
+ | `remove_notes_by_id` | Remove specific notes by ID |
354
+ | `modify_notes` | Change pitch, time, velocity, probability |
355
+ | `duplicate_notes` | Copy notes to new position |
356
+ | `transpose_notes` | Shift pitch by semitones |
357
+ | `quantize_clip` | Quantize to grid |
334
358
 
335
359
  ### Devices (12)
336
- `get_device_info` · `get_device_parameters` · `set_device_parameter` · `batch_set_parameters` · `toggle_device` · `delete_device` · `load_device_by_uri` · `find_and_load_device` · `get_rack_chains` · `set_simpler_playback_mode` · `set_chain_volume` · `get_device_presets`
360
+ | Tool | Description |
361
+ |------|-------------|
362
+ | `get_device_info` | Device name, class, parameters |
363
+ | `get_device_parameters` | All params with names, values, ranges |
364
+ | `set_device_parameter` | Set param by name or index |
365
+ | `batch_set_parameters` | Set multiple params in one call |
366
+ | `toggle_device` | Enable/disable |
367
+ | `delete_device` | Remove from chain |
368
+ | `load_device_by_uri` | Load by browser URI |
369
+ | `find_and_load_device` | Search and load by name |
370
+ | `get_rack_chains` | Get chains in a rack |
371
+ | `set_simpler_playback_mode` | Classic/1-shot/slice |
372
+ | `set_chain_volume` | Set chain volume in rack |
373
+ | `get_device_presets` | List available presets |
337
374
 
338
375
  ### Scenes (8)
339
- `get_scenes_info` · `create_scene` · `delete_scene` · `duplicate_scene` · `fire_scene` · `set_scene_name` · `set_scene_color` · `set_scene_tempo`
376
+ | Tool | Description |
377
+ |------|-------------|
378
+ | `get_scenes_info` | All scenes: name, tempo, color |
379
+ | `create_scene` | New scene |
380
+ | `delete_scene` | Delete a scene |
381
+ | `duplicate_scene` | Copy scene with all clips |
382
+ | `fire_scene` | Launch all clips in scene |
383
+ | `set_scene_name` | Rename |
384
+ | `set_scene_color` | Set color |
385
+ | `set_scene_tempo` | Per-scene tempo |
340
386
 
341
387
  ### Mixing (11)
342
- `set_track_volume` · `set_track_pan` · `set_track_send` · `get_return_tracks` · `get_master_track` · `set_master_volume` · `get_track_routing` · `set_track_routing` · `get_track_meters` · `get_master_meters` · `get_mix_snapshot`
388
+ | Tool | Description |
389
+ |------|-------------|
390
+ | `set_track_volume` | Volume (0.0-1.0) |
391
+ | `set_track_pan` | Pan (-1.0 to 1.0) |
392
+ | `set_track_send` | Send level (0.0-1.0) |
393
+ | `get_return_tracks` | Return track info |
394
+ | `get_master_track` | Master track info |
395
+ | `set_master_volume` | Master volume |
396
+ | `get_track_routing` | Input/output routing |
397
+ | `set_track_routing` | Set routing by display name |
398
+ | `get_track_meters` | Live meter levels |
399
+ | `get_master_meters` | Master meter levels |
400
+ | `get_mix_snapshot` | Full mix state in one call |
343
401
 
344
402
  ### Browser (4)
345
- `get_browser_tree` · `get_browser_items` · `search_browser` · `load_browser_item`
403
+ | Tool | Description |
404
+ |------|-------------|
405
+ | `get_browser_tree` | Browse category tree |
406
+ | `get_browser_items` | List items in a category |
407
+ | `search_browser` | Search by name with filters |
408
+ | `load_browser_item` | Load item by URI |
346
409
 
347
410
  ### Arrangement (19)
348
- `get_arrangement_clips` · `create_arrangement_clip` · `add_arrangement_notes` · `get_arrangement_notes` · `remove_arrangement_notes` · `remove_arrangement_notes_by_id` · `modify_arrangement_notes` · `duplicate_arrangement_notes` · `transpose_arrangement_notes` · `set_arrangement_clip_name` · `set_arrangement_automation` · `back_to_arranger` · `jump_to_time` · `capture_midi` · `start_recording` · `stop_recording` · `get_cue_points` · `jump_to_cue` · `toggle_cue_point`
411
+ | Tool | Description |
412
+ |------|-------------|
413
+ | `get_arrangement_clips` | List arrangement clips |
414
+ | `create_arrangement_clip` | New clip at timeline position |
415
+ | `add_arrangement_notes` | Add MIDI notes to arrangement clip |
416
+ | `get_arrangement_notes` | Read arrangement notes |
417
+ | `remove_arrangement_notes` | Remove notes in region |
418
+ | `remove_arrangement_notes_by_id` | Remove by ID |
419
+ | `modify_arrangement_notes` | Modify arrangement notes |
420
+ | `duplicate_arrangement_notes` | Copy notes |
421
+ | `transpose_arrangement_notes` | Shift pitch |
422
+ | `set_arrangement_clip_name` | Rename arrangement clip |
423
+ | `set_arrangement_automation` | Write arrangement automation |
424
+ | `back_to_arranger` | Switch to arrangement view |
425
+ | `jump_to_time` | Seek to beat position |
426
+ | `capture_midi` | Capture played MIDI |
427
+ | `start_recording` | Start recording |
428
+ | `stop_recording` | Stop recording |
429
+ | `get_cue_points` | List cue points |
430
+ | `jump_to_cue` | Jump to cue point |
431
+ | `toggle_cue_point` | Add/remove cue point |
349
432
 
350
433
  ### Automation (8)
351
- `get_clip_automation` · `set_clip_automation` · `clear_clip_automation` · `apply_automation_shape` · `apply_automation_recipe` · `get_automation_recipes` · `generate_automation_curve` · `analyze_for_automation`
434
+ | Tool | Description |
435
+ |------|-------------|
436
+ | `get_clip_automation` | List envelopes on a clip |
437
+ | `set_clip_automation` | Write automation points |
438
+ | `clear_clip_automation` | Clear envelopes |
439
+ | `apply_automation_shape` | Generate + write curve in one call |
440
+ | `apply_automation_recipe` | Apply named recipe |
441
+ | `get_automation_recipes` | List all 15 recipes |
442
+ | `generate_automation_curve` | Preview curve without writing |
443
+ | `analyze_for_automation` | Spectral analysis + suggestions |
352
444
 
353
445
  ### Memory (8)
354
- `memory_learn` · `memory_recall` · `memory_get` · `memory_replay` · `memory_list` · `memory_favorite` · `memory_update` · `memory_delete`
355
-
356
- ### Analyzer (20) — requires LivePilot Analyzer M4L device on master track
357
- `get_master_spectrum` · `get_master_rms` · `get_detected_key` · `get_hidden_parameters` · `get_automation_state` · `walk_device_tree` · `get_clip_file_path` · `replace_simpler_sample` · `load_sample_to_simpler` · `get_simpler_slices` · `crop_simpler` · `reverse_simpler` · `warp_simpler` · `get_warp_markers` · `add_warp_marker` · `move_warp_marker` · `remove_warp_marker` · `scrub_clip` · `stop_scrub` · `get_display_values`
446
+ | Tool | Description |
447
+ |------|-------------|
448
+ | `memory_learn` | Save a technique |
449
+ | `memory_recall` | Search by text/mood/genre |
450
+ | `memory_list` | Browse library |
451
+ | `memory_get` | Get full technique with payload |
452
+ | `memory_update` | Update a technique |
453
+ | `memory_delete` | Delete a technique |
454
+ | `memory_favorite` | Toggle favorite |
455
+ | `memory_replay` | Replay saved technique |
456
+
457
+ ### Analyzer (20) `[M4L]`
458
+ | Tool | Description |
459
+ |------|-------------|
460
+ | `get_master_spectrum` | 8-band frequency analysis |
461
+ | `get_master_rms` | RMS and peak levels |
462
+ | `get_detected_key` | Krumhansl-Schmuckler key detection |
463
+ | `get_hidden_parameters` | All params including hidden ones |
464
+ | `get_automation_state` | Automation state per parameter |
465
+ | `walk_device_tree` | Recursive device chain tree (6 levels) |
466
+ | `get_display_values` | Human-readable param values |
467
+ | `get_clip_file_path` | Audio file path on disk |
468
+ | `replace_simpler_sample` | Load audio into Simpler |
469
+ | `load_sample_to_simpler` | Bootstrap Simpler + load sample |
470
+ | `get_simpler_slices` | Slice point positions |
471
+ | `crop_simpler` | Crop to active region |
472
+ | `reverse_simpler` | Reverse sample |
473
+ | `warp_simpler` | Time-stretch to N beats |
474
+ | `get_warp_markers` | Get all warp markers |
475
+ | `add_warp_marker` | Add warp marker |
476
+ | `move_warp_marker` | Move warp marker |
477
+ | `remove_warp_marker` | Remove warp marker |
478
+ | `scrub_clip` | Preview at beat position |
479
+ | `stop_scrub` | Stop preview |
358
480
 
359
481
  ### Theory (7)
360
- `analyze_harmony` · `suggest_next_chord` · `detect_theory_issues` · `identify_scale` · `harmonize_melody` · `generate_countermelody` · `transpose_smart`
482
+ | Tool | Description |
483
+ |------|-------------|
484
+ | `analyze_harmony` | Chord-by-chord Roman numeral analysis |
485
+ | `suggest_next_chord` | Theory-valid continuations with style presets |
486
+ | `detect_theory_issues` | Parallel 5ths, out-of-key, voice crossing |
487
+ | `identify_scale` | Key/mode detection with confidence ranking |
488
+ | `harmonize_melody` | 2 or 4-voice SATB harmonization |
489
+ | `generate_countermelody` | Species counterpoint (1st/2nd) |
490
+ | `transpose_smart` | Diatonic or chromatic transposition |
361
491
 
362
492
  ### Generative (5)
363
- `generate_euclidean_rhythm` · `layer_euclidean_rhythms` · `generate_tintinnabuli` · `generate_phase_shift` · `generate_additive_process`
493
+ | Tool | Description |
494
+ |------|-------------|
495
+ | `generate_euclidean_rhythm` | Bjorklund algorithm, identifies named rhythms |
496
+ | `layer_euclidean_rhythms` | Stack patterns for polyrhythmic textures |
497
+ | `generate_tintinnabuli` | Arvo Pärt — triad voice from melody |
498
+ | `generate_phase_shift` | Steve Reich — drifting canon |
499
+ | `generate_additive_process` | Philip Glass — expanding/contracting melody |
364
500
 
365
501
  ### Harmony (4)
366
- `navigate_tonnetz` · `find_voice_leading_path` · `classify_progression` · `suggest_chromatic_mediants`
502
+ | Tool | Description |
503
+ |------|-------------|
504
+ | `navigate_tonnetz` | PRL neighbors at depth N |
505
+ | `find_voice_leading_path` | Shortest path between two chords |
506
+ | `classify_progression` | Identify neo-Riemannian pattern |
507
+ | `suggest_chromatic_mediants` | All chromatic mediant relations |
367
508
 
368
509
  ### MIDI I/O (4)
369
- `export_clip_midi` · `import_midi_to_clip` · `analyze_midi_file` · `extract_piano_roll`
370
-
371
- </details>
372
-
373
- ---
374
-
375
- ## Plugin
376
-
377
- The plugin adds a skill, an autonomous agent, and 5 slash commands on top of the MCP tools.
378
-
379
- ```bash
380
- claude plugin add github:dreamrec/LivePilot/plugin
381
- ```
382
-
383
- ### Commands
384
-
385
- | Command | Description |
386
- |---------|-------------|
387
- | `/session` | Full session overview with diagnostics |
388
- | `/beat` | Guided beat creation — genre, tempo, instrumentation |
389
- | `/mix` | Mixing assistant — levels, panning, sends |
390
- | `/sounddesign` | Sound design workflow — instruments, effects, presets |
391
- | `/memory` | Browse, search, and manage your technique library |
392
-
393
- ### Producer Agent
394
-
395
- Autonomous agent that handles multi-step production tasks end-to-end. "Make a lo-fi hip hop beat at 75 BPM" triggers a full pipeline: consult the technique memory for style context, search the device atlas for the right drum kit and instruments, create tracks, program MIDI, chain effects, set levels — then read the spectrum through the analyzer to verify everything sounds right.
396
-
397
- The agent ships with a 2,700-line reference corpus (drum patterns, chord voicings, sound design recipes, mixing templates) and consults the technique memory by default. Mandatory health checks between each stage verify every track produces audible output — the analyzer confirms what the meters suggest.
398
-
399
- ### Core Skill
400
-
401
- `livepilot-core` encodes the operational discipline that connects all three layers. It teaches the AI to consult the device atlas before loading instruments, read the analyzer after mixing moves, check technique memory before creative decisions, and verify every mutation through state reads. It enforces the rules that prevent silent failures: never load empty Drum Racks, never hallucinate device names, always verify audio output. Without it, an LLM with access to the tools will produce silent tracks and load wrong devices.
402
-
403
- ---
404
-
405
- ## M4L Analyzer
406
-
407
- The LivePilot Analyzer (`LivePilot_Analyzer.amxd`) gives the AI ears. Drop it on the master track and 20 additional tools unlock: 8-band spectral analysis, RMS/peak metering, Krumhansl-Schmuckler key detection, plus deep LOM access for sample manipulation, warp markers, device introspection, and human-readable parameter display values.
408
-
409
- All 115 core tools work without it. The analyzer is what turns LivePilot from a remote control into a feedback loop — the AI can set an EQ curve and then read the spectrum to verify the result.
510
+ | Tool | Description |
511
+ |------|-------------|
512
+ | `export_clip_midi` | Export clip to .mid file |
513
+ | `import_midi_to_clip` | Import .mid into session clip |
514
+ | `analyze_midi_file` | Offline MIDI analysis |
515
+ | `extract_piano_roll` | 2D velocity matrix extraction |
410
516
 
411
517
  ---
412
518
 
413
- ## The Landscape
414
-
415
- There are **15+ MCP servers for Ableton Live** as of March 2026. Here's how the major ones compare:
416
-
417
- ### At a Glance
418
-
419
- | | [LivePilot](https://github.com/dreamrec/LivePilot) | [AbletonMCP](https://github.com/ahujasid/ableton-mcp) | [MCP Extended](https://github.com/uisato/ableton-mcp-extended) | [Ableton Copilot](https://github.com/xiaolaa2/ableton-copilot-mcp) | [AbletonBridge](https://github.com/hidingwill/AbletonBridge) | [Producer Pal](https://github.com/adamjmurray/producer-pal) |
420
- |---|:-:|:-:|:-:|:-:|:-:|:-:|
421
- | **Tools** | 155 | ~20 | ~35 | ~45 | 322 | ~25 |
422
- | **Device knowledge** | 280+ devices | -- | -- | -- | -- | -- |
423
- | **Audio analysis** | Spectrum/RMS/key | -- | -- | -- | Metering | -- |
424
- | **Technique memory** | Persistent | -- | -- | -- | -- | -- |
425
- | **Stars** | new | 2.3k | 139 | 72 | 13 | 103 |
426
- | **Language** | Python | Python | Python | TypeScript | Python | TypeScript |
427
- | **Active** | Yes | Slow | Yes | Yes | Yes | Yes |
428
-
429
- ### Feature Comparison
430
-
431
- | Capability | LivePilot | AbletonMCP | Extended | Copilot | Bridge | Producer Pal |
432
- |---|:-:|:-:|:-:|:-:|:-:|:-:|
433
- | Transport | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
434
- | Tracks (MIDI/audio/return) | ✅ | Partial | ✅ | ✅ | ✅ | ✅ |
435
- | Session clips | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
436
- | **Arrangement view** | ✅ | — | — | ✅ | ? | ? |
437
- | **Arrangement automation** | ✅ | — | — | — | ? | — |
438
- | **Clip automation (envelopes)** | ✅ | — | — | — | — | — |
439
- | **Automation curve engine** | ✅ | — | — | — | — | — |
440
- | MIDI notes (add/get) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
441
- | **MIDI notes (modify/delete by ID)** | ✅ | — | — | ✅ | ? | — |
442
- | **Per-note probability** | ✅ | — | — | — | — | — |
443
- | Device loading | ✅ | ✅ | ✅ | ✅ | ✅ | ? |
444
- | Device parameters | ✅ | Basic | ✅ | ✅ | ✅ | ? |
445
- | **Batch parameter editing** | ✅ | — | — | — | ? | — |
446
- | **Rack chains** | ✅ | — | — | — | ✅ | — |
447
- | Browser (tree/search/URI) | ✅ | Basic | ✅ | ✅ | ✅ | — |
448
- | **Plugin browser (AU/VST)** | ✅ | — | — | — | ? | — |
449
- | Mixing (vol/pan/sends) | ✅ | Basic | ✅ | Basic | ✅ | ? |
450
- | **Master track control** | ✅ | — | — | — | ✅ | — |
451
- | Scenes | ✅ | — | ✅ | ? | ✅ | ✅ |
452
- | **Undo wrapping** | ✅ | — | Partial | — | ? | — |
453
- | **Session diagnostics** | ✅ | — | — | — | — | — |
454
- | **Technique memory** | ✅ | — | — | — | — | — |
455
- | **AI plugin (skills/agent)** | ✅ | — | — | — | — | — |
456
- | **Device Atlas (built-in)** | ✅ | — | — | — | — | — |
457
- | **Auto-detect installer** | ✅ | — | — | ✅ | — | — |
458
- | Snapshots/rollback | — | — | — | ✅ | — | — |
459
- | Voice generation | — | — | — | — | ✅ | — |
460
- | **Real-time DSP analysis** | ✅ | — | — | — | ✅ | — |
461
- | M4L-native install | — | — | — | — | — | ✅ |
462
- | Multi-LLM support | Any MCP | Claude | Claude | Any MCP | Any MCP | Multi |
463
-
464
- ### Also Notable
465
-
466
- - **[Simon-Kansara](https://github.com/Simon-Kansara/ableton-live-mcp-server)** (369★) — OSC-based, exhaustive address mapping, inactive since 2025
467
- - **[jpoindexter](https://github.com/jpoindexter/ableton-mcp)** — 200+ tools, triple interface (MCP + REST + M4L), 13 scales
468
- - **[cafeTechne](https://github.com/cafeTechne/ableton-11-mcp-for-windows-codex-and-antigravity)** — 220+ tools, Windows/Codex optimized, Live 11 focused
469
- - **[FabianTinkl](https://github.com/FabianTinkl/AbletonMCP)** — AI-powered chord/melody generation, genre-specific composition
470
- - **[nozomi-koborinai](https://github.com/nozomi-koborinai/ableton-osc-mcp)** — Only Go implementation, uses Google Genkit
471
-
472
- ### Where LivePilot Fits
473
-
474
- Every server on this list gives the AI tools to control Ableton. LivePilot is the only one that also gives it **knowledge** (device atlas with 280+ devices, 139 kits, 350+ IRs), **perception** (real-time spectrum, RMS, key detection from the M4L analyzer), and **memory** (persistent technique library that accumulates production decisions across sessions).
475
-
476
- The practical difference: other servers let the AI set a parameter. LivePilot lets the AI choose the right parameter based on what device is loaded (atlas), verify the result by reading the audio output (analyzer), and remember the technique for next time (memory).
477
-
478
- AbletonBridge has more raw tools (322 vs 155). Producer Pal has the easiest install (drag a .amxd). The original AbletonMCP has the community (2.3k stars). LivePilot has the deepest integration — tools that execute, knowledge that informs, perception that verifies, and memory that accumulates.
479
-
480
- ---
481
-
482
- ## Architecture
519
+ ## Coming ────────────────────────────────────────
483
520
 
484
521
  ```
485
- AI Client
486
- │ MCP Protocol (stdio)
487
- ▼
488
- ┌─────────────────────┐
489
- │ MCP Server │ Python (FastMCP)
490
- │ mcp_server/ │ Input validation, auto-reconnect
491
- └────────┬────────────┘
492
- │ JSON over TCP (port 9878)
493
- ▼
494
- ┌─────────────────────┐
495
- │ Remote Script │ Runs inside Ableton's Python
496
- │ remote_script/ │ Thread-safe command queue
497
- │ LivePilot/ │ ControlSurface base class
498
- └─────────────────────┘
522
+ □ Real-time DSP analysis via LOM meters
523
+ □ M4L bridge expansion — deeper LiveAPI access
524
+ □ Arrangement view — clip placement, tempo automation
525
+ □ Audio clip manipulation — stretch, slice, resample
526
+ □ Plugin parameter mapping — VST/AU deep control
499
527
  ```
500
528
 
501
- All commands execute on Ableton's main thread via `schedule_message` — the same thread that handles the UI. This guarantees consistency with what you see on screen. Single-client TCP by design, because Ableton's Live Object Model is not thread-safe.
502
-
503
- **Structured errors** with codes (`INDEX_ERROR`, `NOT_FOUND`, `INVALID_PARAM`, `STATE_ERROR`, `TIMEOUT`, `INTERNAL`) so the AI can understand what went wrong and recover.
504
-
505
- ---
506
-
507
- ## Compatibility
508
-
509
- | | Live 12 (all editions) | Suite only |
510
- |---|:---:|:---:|
511
- | Transport, tracks, clips, scenes, mixing | Yes | — |
512
- | MIDI notes (add, modify, remove, probability) | Yes | — |
513
- | Device parameters, effects, browser | Yes | — |
514
- | Arrangement (clips, notes, cue points) | Yes | — |
515
- | Stock instruments (Drift, Meld, Wavetable) | — | Yes |
516
- | Max for Live devices | — | Yes |
517
- | Third-party VST/AU plugins | Yes | — |
518
-
519
- **Requirements:** Ableton Live 12 · Python 3.9+ · Node.js 18+
520
-
521
529
  ---
522
530
 
523
531
  ## CLI
@@ -531,28 +539,21 @@ npx livepilot --doctor # Full diagnostic check
531
539
  npx livepilot --version # Show version
532
540
  ```
533
541
 
534
- ---
535
-
536
- ## Documentation
537
-
538
- **[Read the full manual](docs/manual/index.md)** — Getting started, tool reference, production workflows, MIDI programming, sound design, mixing, and troubleshooting.
542
+ ## Compatibility
539
543
 
540
- ---
544
+ Live 12 all editions. Suite required for stock instruments (Drift, Meld, Wavetable) and Max for Live. Python 3.9+. Node.js 18+.
541
545
 
542
546
  ## Development
543
547
 
544
548
  ```bash
545
549
  git clone https://github.com/dreamrec/LivePilot.git
546
550
  cd LivePilot
547
- python3 -m venv .venv
548
- .venv/bin/pip install -r requirements.txt
551
+ python3 -m venv .venv && .venv/bin/pip install -r requirements.txt
549
552
  .venv/bin/pytest tests/ -v
550
553
  ```
551
554
 
552
- ## Contributing
553
-
554
- Contributions welcome. Please [open an issue](https://github.com/dreamrec/LivePilot/issues) first to discuss what you'd like to change.
555
-
556
- ## License
555
+ ---
557
556
 
558
557
  [MIT](LICENSE) — Pilot Studio
558
+
559
+ Sister projects: [TDPilot](https://github.com/dreamrec/TDPilot) (TouchDesigner) · [ComfyPilot](https://github.com/dreamrec/ComfyPilot) (ComfyUI)
package/mcp_server/tools/_theory_engine.py CHANGED
@@ -82,7 +82,7 @@ def pitch_name(midi: int) -> str:
82
82
 
83
83
 
84
84
  def parse_key(key_str: str) -> dict:
85
- """Parse key string -> {tonic: 0-11, mode: str}."""
85
+ """Parse key string -> {tonic: 0-11, tonic_name: str, mode: str}."""
86
86
  parts = key_str.strip().split()
87
87
  raw_tonic = parts[0]
88
88
  mode = parts[1].lower() if len(parts) > 1 else 'major'
@@ -97,7 +97,7 @@ def parse_key(key_str: str) -> dict:
97
97
  if tonic_name not in NOTE_NAMES:
98
98
  raise ValueError(f"Unknown tonic: {tonic_name} (from '{key_str}')")
99
99
 
100
- return {"tonic": NOTE_NAMES.index(tonic_name), "mode": mode}
100
+ return {"tonic": NOTE_NAMES.index(tonic_name), "tonic_name": tonic_name, "mode": mode}
101
101
 
102
102
 
103
103
  def get_scale_pitches(tonic: int, mode: str) -> list[int]:
package/package.json CHANGED
@@ -1,8 +1,8 @@
1
1
  {
2
2
  "name": "livepilot",
3
- "version": "1.7.1",
3
+ "version": "1.7.3",
4
4
  "mcpName": "io.github.dreamrec/livepilot",
5
- "description": "AI copilot for Ableton Live 12 — 155 tools, device atlas (280+ devices), real-time audio analysis, generative algorithms, neo-Riemannian harmony, MIDI file I/O, and technique memory",
5
+ "description": "Agentic production system for Ableton Live 12 — 155 tools, 16 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
6
6
  "author": "Pilot Studio",
7
7
  "license": "MIT",
8
8
  "type": "commonjs",
package/plugin/plugin.json CHANGED
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "name": "livepilot",
3
- "version": "1.7.0",
4
- "description": "AI copilot for Ableton Live 12 — 155 tools, device atlas (280+ devices), real-time audio analysis, generative algorithms, neo-Riemannian harmony, MIDI file I/O, and technique memory",
3
+ "version": "1.7.2",
4
+ "description": "Agentic production system for Ableton Live 12 — 155 tools, 16 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
5
5
  "author": "Pilot Studio",
6
6
  "skills": [
7
7
  "skills/livepilot-core",
package/plugin/skills/livepilot-core/SKILL.md CHANGED
@@ -1,17 +1,17 @@
1
1
  ---
2
2
  name: livepilot-core
3
- description: Core discipline for controlling Ableton Live 12 through LivePilot's 155 MCP tools, device atlas (280+ devices), M4L analyzer (spectrum/RMS/key detection), automation intelligence (16 curve types, 15 recipes), music theory analysis, generative algorithms, neo-Riemannian harmony, MIDI file I/O, and technique memory. Use whenever working with Ableton Live through MCP tools.
3
+ description: Core discipline for LivePilot — agentic production system for Ableton Live 12. 155 tools across 16 domains. Device atlas (280+ devices), M4L analyzer (spectrum/RMS/key detection), technique memory, automation intelligence (16 curve types, 15 recipes), music theory (Krumhansl-Schmuckler, species counterpoint), generative algorithms (Euclidean rhythm, tintinnabuli, phase shift), neo-Riemannian harmony (PRL transforms, Tonnetz), MIDI file I/O. Use whenever working with Ableton Live through MCP tools.
4
4
  ---
5
5
 
6
- # LivePilot Core — Ableton Live 12 AI Copilot
6
+ # LivePilot Core — Ableton Live 12
7
7
 
8
- LivePilot is an agentic production system for Ableton Live 12. It combines 155 MCP tools with three layers of intelligence:
8
+ Agentic production system for Ableton Live 12. 155 tools across 16 domains, three layers:
9
9
 
10
10
  - **Device Atlas** — A structured knowledge corpus of 280+ instruments, 139 drum kits, and 350+ impulse responses. Consult the atlas before loading any device. It contains real browser URIs, preset names, and sonic descriptions. Never guess a device name — look it up.
11
11
  - **M4L Analyzer** — Real-time audio analysis on the master bus (8-band spectrum, RMS/peak, key detection). Use it to verify mixing decisions, detect frequency problems, and find the key before writing harmonic content.
12
12
  - **Technique Memory** — Persistent storage for production decisions. Consult `memory_recall` before creative tasks to understand the user's taste. Save techniques when the user likes something. The memory shapes future decisions without constraining them.
13
13
 
14
- These layers sit on top of 155 deterministic tools across 16 domains: transport, tracks, clips, MIDI notes, devices, scenes, mixing, browser, arrangement, technique memory, real-time DSP analysis, automation, music theory, generative algorithms, neo-Riemannian harmony, and MIDI file I/O.
14
+ These layers sit on top of 155 deterministic tools across 16 domains: transport, tracks, clips, notes, devices, scenes, mixing, browser, arrangement, memory, analyzer, automation, theory, generative, harmony, and MIDI I/O.
15
15
 
16
16
  ## Golden Rules
17
17
 
package/plugin/skills/livepilot-core/references/overview.md CHANGED
@@ -1,6 +1,6 @@
1
- # LivePilot v1.7.0 — Architecture & Tool Reference
1
+ # LivePilot v1.7.2 — Architecture & Tool Reference
2
2
 
3
- LivePilot is an agentic production system for Ableton Live 12. It combines 155 MCP tools with a device knowledge corpus, real-time audio analysis, automation intelligence, generative algorithms, neo-Riemannian harmony, MIDI file I/O, and persistent technique memory.
3
+ Agentic production system for Ableton Live 12. 155 tools across 16 domains. Device atlas (280+ devices), spectral perception (M4L analyzer), technique memory, automation intelligence (16 curve types, 15 recipes), music theory (Krumhansl-Schmuckler, species counterpoint), generative algorithms (Euclidean rhythm, tintinnabuli, phase shift, additive process), neo-Riemannian harmony (PRL transforms, Tonnetz), MIDI file I/O.
4
4
 
5
5
  ## Architecture
6
6