livepilot 1.2.1 → 1.3.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 1.3.0 — 2026-03-17
+
+### Enhancements
+- **Device tools now support return tracks and master track** — use negative `track_index` for return tracks (-1=A, -2=B) and -1000 for master track. Works with all 12 device tools: `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`
+- **Mixing tools now support return tracks** — `set_track_volume`, `set_track_pan`, `get_track_routing`, `set_track_routing` accept negative indices for return tracks
+- Fixed `quantize_clip` grid parameter documentation — was incorrectly documented as float beats, now correctly documented as integer enum (0-8)
+- Fixed tempo range typo in SKILL.md (was 20-969, corrected to 20-999)
+
 ## 1.2.1 — 2026-03-17
 
 ### Fixes

package/README.md

@@ -13,16 +13,44 @@
 
 **AI copilot for Ableton Live 12** — 96 MCP tools for music production, sound design, and mixing.
 
-Control your entire Ableton session through natural language. Create tracks, program MIDI, load instruments, tweak parameters, arrange songs, and mix — all without leaving the keyboard.
+Talk to your DAW. Create tracks, program MIDI, load instruments, tweak parameters, arrange songs, and mix — all through natural language. LivePilot connects any MCP-compatible AI client (Claude, Cursor, VS Code Copilot) to Ableton Live and gives it full control over your session.
+
+---
+
+## What it feels like
+
+```
+You:    "Set up a 126 BPM session with a drum track and a bass track"
+Claude: Sets tempo to 126. Creates MIDI track "DRUMS" and "BASS".
+        Searches browser for a drum kit, loads "606 Core Kit".
+        Verifies kit loaded — Drum Rack with 16 chains. ✓
+
+You:    "Program a four-on-the-floor kick with offbeat hi-hats, 2 bars"
+Claude: Creates 8-beat clip, adds kicks on every beat (pitch 36, velocity 110),
+        closed hats on offbeats (pitch 42, velocity 80/60 alternating).
+        Fires the clip.
+
+You:    "The hats are too loud, bring them down and add some swing"
+Claude: Reads note IDs, modifies hat velocities to 65/45.
+        Adds ghost snare hits at 30% probability on the "e" and "ah".
+        The pattern evolves slightly every loop.
+
+You:    "Find an analog bass preset and write a simple sub line in D minor"
+Claude: Searches instruments for "Analog Bass", loads a preset onto BASS track.
+        Adds root notes (D1 = pitch 38) with octave bounces.
+        Sets bass volume to 0.65, pans center. Fires to listen.
+```
+
+Every command goes through Ableton's official Live Object Model API. No hacks, no injection — the same interface Ableton's own control surfaces use. Everything is deterministic and reversible with undo.
 
 ---
 
 ## What You Can Do
 
 - **Produce** — Create tracks, load instruments, program drum patterns, bass lines, chord progressions, and melodies
-- **Arrange** — Build full song structures in arrangement view with MIDI note editing, cue points, and timeline navigation
-- **Design sounds** — Browse Ableton's library, load presets, tweak device parameters, chain effects
-- **Mix** — Set levels, panning, sends, and routing. Run diagnostics to catch silent tracks and mute leftovers
+- **Arrange** — Build full song structures in arrangement view with MIDI editing, cue points, automation, and timeline navigation
+- **Design sounds** — Browse Ableton's library, load presets, tweak every device parameter, chain effects
+- **Mix** — Set levels, panning, sends, and routing. Run diagnostics to catch silent tracks and stale solos
 - **Iterate fast** — Transpose, humanize, quantize, duplicate, and reshape patterns through conversation
 
 ---
@@ -215,7 +243,34 @@ The plugin adds production-focused skills, slash commands, and an autonomous pro
 | `/mix` | Mixing assistant — levels, panning, sends |
 | `/sounddesign` | Sound design workflow — instruments, effects, presets |
 
-**Producer Agent** — An autonomous agent that builds tracks from high-level descriptions like *"Make me a 126 BPM rominimal track in D minor with hypnotic percussion"*.
+**Producer Agent** — An autonomous agent that builds tracks from high-level descriptions like *"Make me a 126 BPM rominimal track in D minor with hypnotic percussion"*. It handles the full pipeline: track creation, instrument loading, pattern programming, effects, and mixing.
+
+**Core Skill** — The `livepilot-core` skill teaches the AI how to work with Ableton properly: always read session state first, verify after every write, check that instruments actually loaded, never program notes at wrong pitches for drum kits. It's the difference between an AI that fumbles through the API and one that works like an experienced assistant.
+
+---
+
+## How It Compares
+
+| Feature | LivePilot | [AbletonMCP](https://github.com/ahujasid/ableton-mcp) | [Ableton MCP Extended](https://github.com/uisato/ableton-mcp-extended) |
+|---------|:---------:|:---------:|:---------:|
+| **Tools** | 96 | ~20 | ~50 |
+| **Arrangement view** | Full (clips, notes, cue points, automation) | No | Partial (automation "not perfect yet") |
+| **MIDI note editing** | Full CRUD with note IDs, probability, velocity deviation | Basic add/get | Add/get/modify |
+| **Device control** | Load, params, batch edit, rack chains, presets, Simpler modes | Load, basic params | Load, params |
+| **Browser search** | Tree navigation, path filtering, URI-based loading | Basic search | Search with categories |
+| **Mixing** | Volume, pan, sends, routing, master, diagnostics | Volume, pan | Volume, pan, sends |
+| **Undo support** | Full (begin/end_undo_step wrapping) | No | Partial |
+| **Session diagnostics** | Built-in health checks (armed tracks, solos, silent tracks) | No | No |
+| **Per-note probability** | Yes (Live 12 API) | No | No |
+| **Plugin/skills** | Claude Code plugin with 4 commands + producer agent | No | No |
+| **Voice generation** | No | No | Yes (ElevenLabs) |
+| **UDP low-latency mode** | No (TCP, reliable) | No | Yes (experimental) |
+| **Protocol** | JSON/TCP, single-client, structured errors | JSON/TCP | JSON/TCP + UDP |
+| **Installation** | Auto-detect CLI (`--install`) | Manual copy | Manual copy |
+| **Live version** | Live 12 (modern note API) | Live 11+ | Live 11+ |
+| **License** | MIT | MIT | MIT |
+
+LivePilot focuses on **comprehensive, deterministic control** with safety nets (undo wrapping, diagnostics, verification patterns). It trades real-time parameter streaming (Extended's UDP mode) and external service integration (Extended's ElevenLabs) for deeper coverage of Ableton's core operations — especially arrangement, device management, and MIDI editing with Live 12's modern note API.
 
 ---
 
@@ -238,7 +293,9 @@ Claude / AI Client
 └─────────────────────┘
 ```
 
-Single-client TCP connection by design — Ableton's Live Object Model is not thread-safe.
+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.
+
+**Structured errors** with codes (`INDEX_ERROR`, `NOT_FOUND`, `INVALID_PARAM`, `STATE_ERROR`, `TIMEOUT`, `INTERNAL`) so the AI can understand what went wrong and recover.
 
 ---
 

package/mcp_server/tools/devices.py

@@ -23,9 +23,17 @@ def _get_ableton(ctx: Context):
     return ctx.lifespan_context["ableton"]
 
 
+MASTER_TRACK_INDEX = -1000
+
+
 def _validate_track_index(track_index: int):
-    if track_index < 0:
-        raise ValueError("track_index must be >= 0")
+    if track_index < 0 and track_index != MASTER_TRACK_INDEX:
+        if track_index < -100:
+            raise ValueError(
+                "track_index must be >= 0 for regular tracks, "
+                "negative for return tracks (-1=A, -2=B), or -1000 for master"
+            )
+        # Negative values -1..-99 are valid return track indices
 
 
 def _validate_device_index(device_index: int):
@@ -40,7 +48,8 @@ def _validate_chain_index(chain_index: int):
 
 @mcp.tool()
 def get_device_info(ctx: Context, track_index: int, device_index: int) -> dict:
-    """Get info about a device: name, class, type, active state, parameter count."""
+    """Get info about a device: name, class, type, active state, parameter count.
+    track_index: 0+ for regular tracks, -1/-2/... for return tracks (A/B/...), -1000 for master."""
     _validate_track_index(track_index)
     _validate_device_index(device_index)
     return _get_ableton(ctx).send_command("get_device_info", {
@@ -51,7 +60,8 @@ def get_device_info(ctx: Context, track_index: int, device_index: int) -> dict:
 
 @mcp.tool()
 def get_device_parameters(ctx: Context, track_index: int, device_index: int) -> dict:
-    """Get all parameters for a device with names, values, and ranges."""
+    """Get all parameters for a device with names, values, and ranges.
+    track_index: 0+ for regular tracks, -1/-2/... for return tracks (A/B/...), -1000 for master."""
     _validate_track_index(track_index)
     _validate_device_index(device_index)
     return _get_ableton(ctx).send_command("get_device_parameters", {
@@ -69,7 +79,8 @@ def set_device_parameter(
     parameter_name: str | None = None,
     parameter_index: int | None = None,
 ) -> dict:
-    """Set a device parameter by name or index."""
+    """Set a device parameter by name or index.
+    track_index: 0+ for regular tracks, -1/-2/... for return tracks (A/B/...), -1000 for master."""
     _validate_track_index(track_index)
     _validate_device_index(device_index)
     if parameter_name is None and parameter_index is None:
@@ -95,7 +106,8 @@ def batch_set_parameters(
     device_index: int,
     parameters: Any,
 ) -> dict:
-    """Set multiple device parameters in one call. parameters is a JSON array: [{name_or_index, value}]."""
+    """Set multiple device parameters in one call. parameters is a JSON array: [{name_or_index, value}].
+    track_index: 0+ for regular tracks, -1/-2/... for return tracks (A/B/...), -1000 for master."""
     _validate_track_index(track_index)
     _validate_device_index(device_index)
     parameters = _ensure_list(parameters)
@@ -113,7 +125,8 @@ def batch_set_parameters(
 
 @mcp.tool()
 def toggle_device(ctx: Context, track_index: int, device_index: int, active: bool) -> dict:
-    """Enable or disable a device."""
+    """Enable or disable a device.
+    track_index: 0+ for regular tracks, -1/-2/... for return tracks (A/B/...), -1000 for master."""
     _validate_track_index(track_index)
     _validate_device_index(device_index)
     return _get_ableton(ctx).send_command("toggle_device", {
@@ -125,7 +138,8 @@ def toggle_device(ctx: Context, track_index: int, device_index: int, active: boo
 
 @mcp.tool()
 def delete_device(ctx: Context, track_index: int, device_index: int) -> dict:
-    """Delete a device from a track. Use undo to revert if needed."""
+    """Delete a device from a track. Use undo to revert if needed.
+    track_index: 0+ for regular tracks, -1/-2/... for return tracks (A/B/...), -1000 for master."""
     _validate_track_index(track_index)
     _validate_device_index(device_index)
     return _get_ableton(ctx).send_command("delete_device", {
@@ -136,7 +150,8 @@ def delete_device(ctx: Context, track_index: int, device_index: int) -> dict:
 
 @mcp.tool()
 def load_device_by_uri(ctx: Context, track_index: int, uri: str) -> dict:
-    """Load a device onto a track using a browser URI string."""
+    """Load a device onto a track using a browser URI string.
+    track_index: 0+ for regular tracks, -1/-2/... for return tracks (A/B/...), -1000 for master."""
     _validate_track_index(track_index)
     if not uri.strip():
         raise ValueError("URI cannot be empty")
@@ -148,7 +163,8 @@ def load_device_by_uri(ctx: Context, track_index: int, uri: str) -> dict:
 
 @mcp.tool()
 def find_and_load_device(ctx: Context, track_index: int, device_name: str) -> dict:
-    """Search the browser for a device by name and load it onto a track."""
+    """Search the browser for a device by name and load it onto a track.
+    track_index: 0+ for regular tracks, -1/-2/... for return tracks (A/B/...), -1000 for master."""
     _validate_track_index(track_index)
     if not device_name.strip():
         raise ValueError("device_name cannot be empty")

package/mcp_server/tools/mixing.py

@@ -14,13 +14,17 @@ def _get_ableton(ctx: Context):
 
 
 def _validate_track_index(track_index: int):
-    if track_index < 0:
-        raise ValueError("track_index must be >= 0")
+    if track_index < -100:
+        raise ValueError(
+            "track_index must be >= 0 for regular tracks, "
+            "or negative for return tracks (-1=A, -2=B)"
+        )
+    # Negative values -1..-99 are valid return track indices
 
 
 @mcp.tool()
 def set_track_volume(ctx: Context, track_index: int, volume: float) -> dict:
-    """Set a track's volume (0.0-1.0)."""
+    """Set a track's volume (0.0-1.0). Use negative track_index for return tracks (-1=A, -2=B)."""
     _validate_track_index(track_index)
     if not 0.0 <= volume <= 1.0:
         raise ValueError("Volume must be between 0.0 and 1.0")
@@ -32,7 +36,7 @@ def set_track_volume(ctx: Context, track_index: int, volume: float) -> dict:
 
 @mcp.tool()
 def set_track_pan(ctx: Context, track_index: int, pan: float) -> dict:
-    """Set a track's panning (-1.0 left to 1.0 right)."""
+    """Set a track's panning (-1.0 left to 1.0 right). Use negative track_index for return tracks (-1=A, -2=B)."""
     _validate_track_index(track_index)
     if not -1.0 <= pan <= 1.0:
         raise ValueError("Pan must be between -1.0 and 1.0")
@@ -81,7 +85,7 @@ def set_master_volume(ctx: Context, volume: float) -> dict:
 
 @mcp.tool()
 def get_track_routing(ctx: Context, track_index: int) -> dict:
-    """Get input/output routing info for a track."""
+    """Get input/output routing info for a track. Use negative track_index for return tracks (-1=A, -2=B)."""
     _validate_track_index(track_index)
     return _get_ableton(ctx).send_command("get_track_routing", {
         "track_index": track_index,
@@ -97,7 +101,7 @@ def set_track_routing(
     output_type: str | None = None,
     output_channel: str | None = None,
 ) -> dict:
-    """Set input/output routing for a track by display name."""
+    """Set input/output routing for a track by display name. Use negative track_index for return tracks (-1=A, -2=B)."""
     _validate_track_index(track_index)
     params = {"track_index": track_index}
     if input_type is not None:

package/mcp_server/tools/notes.py

@@ -4,7 +4,7 @@
 """
 
 import json
-from typing import Any, Optional
+from typing import Any
 
 from fastmcp import Context
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "mcpName": "io.github.dreamrec/livepilot",
   "description": "AI copilot for Ableton Live 12 — 96 MCP tools for music production, sound design, and mixing",
   "author": "Pilot Studio",

package/plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "AI copilot for Ableton Live 12 — 96 MCP tools for music production, sound design, and mixing",
   "author": "Pilot Studio",
   "skills": [

package/plugin/skills/livepilot-core/SKILL.md

@@ -13,10 +13,10 @@ LivePilot gives you 96 MCP tools to control Ableton Live 12 in real-time: transp
 2. **Verify after every write** — re-read state to confirm your change took effect
 3. **Use `undo` liberally** — it's your safety net. Mention it to users when doing destructive ops
 4. **One operation at a time** — don't batch unrelated changes. Verify between steps
-5. **Track indices are 0-based** — track 0 is the first track, scene 0 is the first scene
+5. **Track indices are 0-based** — track 0 is the first track. Use negative indices for return tracks (-1=A, -2=B). Use -1000 for master track.
 6. **Color indices 0-69** — Ableton's fixed palette. Don't guess — use the index
 7. **Volume is 0.0-1.0, pan is -1.0 to 1.0** — these are normalized, not dB
-8. **Tempo range 20-969 BPM** — validated before sending to Ableton
+8. **Tempo range 20-999 BPM** — validated before sending to Ableton
 9. **Always name your tracks and clips** — organization is part of the creative process
 
 ## Track Health Checks — MANDATORY
@@ -144,7 +144,7 @@ When reading with `get_notes`, you also get:
 Use `modify_notes` with `note_id` to update existing notes.
 Use `remove_notes_by_id` for surgical deletion.
 Use `transpose_notes` for pitch shifting a region.
-Use `quantize_clip` to snap notes to a grid (grid=1.0 is quarter note).
+Use `quantize_clip` to snap notes to a grid (grid is an enum: 1=1/4, 2=1/8, 5=1/16, 8=1/32).
 
 ## Reference Corpus
 

package/plugin/skills/livepilot-core/references/overview.md

@@ -79,7 +79,7 @@ Claude Code  ──MCP──►  FastMCP Server  ──TCP/9878──►  Remote
 | `modify_notes` | Changes existing notes (pitch, time, velocity, probability) | `track_index`, `clip_index`, `modifications` |
 | `duplicate_notes` | Copies notes in a region | `track_index`, `clip_index`, region params |
 | `transpose_notes` | Shifts pitch of notes in a region | `track_index`, `clip_index`, `semitones`, region params |
-| `quantize_clip` | Snaps notes to grid | `track_index`, `clip_index`, `grid` (1.0=quarter), `amount` (0-1) |
+| `quantize_clip` | Snaps notes to grid | `track_index`, `clip_index`, `grid` (int 0-8: 0=None,1=1/4,2=1/8,5=1/16,8=1/32), `amount` (0-1) |
 
 **Note format** (for `add_notes`):
 ```json
@@ -181,8 +181,8 @@ Claude Code  ──MCP──►  FastMCP Server  ──TCP/9878──►  Remote
 | Velocity | 1-127 | 1 = softest, 127 = loudest |
 | Probability | 0.0-1.0 | 1.0 = always triggers |
 | Color index | 0-69 | Ableton's fixed palette |
-| Track index | 0-based | -1 for return tracks: -1=A, -2=B |
-| Grid (quantize) | Beats (float) | 1.0=quarter, 0.5=eighth, 0.25=16th |
+| Track index | 0-based | Negative for return tracks (-1=A, -2=B), -1000 for master |
+| Grid (quantize) | Integer enum (0-8) | 0=None, 1=1/4, 2=1/8, 3=1/8T, 4=1/8+T, 5=1/16, 6=1/16T, 7=1/16+T, 8=1/32 |
 | Time signature | num/denom | denom must be power of 2 |
 
 ## Common Patterns

package/remote_script/LivePilot/utils.py

@@ -39,9 +39,15 @@ def error_response(request_id, message, code=INTERNAL):
 
 # ── Validation helpers ───────────────────────────────────────────────────────
 
+MASTER_TRACK_INDEX = -1000
+
+
 def get_track(song, track_index):
     """Return a track by index (0-based).  Supports negative indices for
-    return tracks: -1 = first return, -2 = second return, etc."""
+    return tracks: -1 = first return, -2 = second return, etc.
+    Use -1000 for the master track."""
+    if track_index == MASTER_TRACK_INDEX:
+        return song.master_track
     tracks = list(song.tracks)
     if track_index < 0:
         return_tracks = list(song.return_tracks)

package/LivePilot audit report.md

@@ -1,87 +0,0 @@
-# Deep audit of the **LivePilot** repository and comparison with other AI‑enabled DAW assistants
-
-## Overview of LivePilot
-
-**LivePilot** is an open‑source Model Context Protocol (MCP) server and companion plug‑in that connects large language models to *Ableton Live 12*.  The project’s goal is to act as an **AI co‑pilot** for music production, sound design and mixing.
-
-* **Purpose and capabilities:** The README explains that LivePilot exposes **91 tools across nine domains** (transport, tracks, clips, notes, devices, scenes, mixing, browser and arrangement)【665853537458845†L43-L70】.  It allows a user to create tracks, program MIDI patterns, load instruments, adjust mixing parameters and even build full song structures via natural‑language requests【665853537458845†L15-L21】.  The tool set covers nearly every aspect of a typical Ableton workflow: starting/stopping playback, setting tempo, creating MIDI or audio tracks, renaming and coloring them, creating/duplicating clips, reading and editing MIDI notes, loading devices and presets, changing levels/pans/sends, browsing Ableton’s library, editing arrangement clips and automation【665853537458845†L43-L70】.  Each tool maps directly to an Ableton Live API call; the manual notes that there is **no abstraction layer** – commands are deterministic and reversible【608977690485721†L23-L27】.
-* **Architecture:** A natural‑language prompt is processed by the AI client (e.g., Claude Code or Cursor) and sent over the MCP to the **LivePilot server** (Python with `fastmcp`)【665853537458845†L90-L97】.  The server validates inputs and forwards them via a single‑client TCP connection to a **Remote Script** that runs inside Ableton’s Python environment【665853537458845†L90-L97】.  The Remote Script executes commands on Ableton’s main thread (the same thread as the GUI), ensuring thread‑safe access to the Live Object Model【608977690485721†L29-L34】.  Installation is streamlined via `npx -y github:dreamrec/LivePilot --install`, which copies the Remote Script to Ableton’s user library and sets up the MCP server【665853537458845†L22-L29】.
-* **Plugin and producer agent:** LivePilot includes a Claude Code plug‑in that provides slash commands (`/session`, `/beat`, `/mix`, `/sounddesign`) and an **autonomous producer agent** that can build complete tracks from high‑level descriptions (“Make me a 126 BPM rominimal track…”)【665853537458845†L82-L89】.  The core skill packaged with the plug‑in teaches the AI how to use LivePilot effectively – checking session state before issuing commands, verifying the results after writes and avoiding common mistakes【692402510651097†L69-L81】.
-* **Documentation and user guidance:** The manual is comprehensive.  It explains installation, connectivity, examples of natural‑language sessions, the details of each tool, production workflows, MIDI programming guidelines, sound design recipes, mixing tips and troubleshooting【608977690485721†L40-L47】.  The getting‑started guide shows how to connect the server, then suggests an example conversation (“What’s in my session?” → “Set the tempo to 120 and create a MIDI track called DRUMS” → “Search for a drum kit and load it onto the DRUMS track” → “Create an 8‑beat clip and program a basic house kick pattern…”)【692402510651097†L39-L51】.
-* **Compatibility:** LivePilot supports Ableton Live 12 (any edition) and requires Python 3.10 or newer and Node.js 18+【665853537458845†L96-L102】.  Arrangement‑related tools work only in Live 12, while loading stock instruments and Max for Live devices requires the Suite edition【665853537458845†L96-L102】.  CLI commands such as `--status`, `--doctor`, `--install` and `--version` simplify installation and diagnostics【665853537458845†L103-L106】.
-
-### Project structure and quality
-
-Because the repository cannot be cloned from the restricted environment, we rely on the README and manual to infer its structure.  The repository contains at least the following components:
-
-1. **Remote script (`remote_script/LivePilot`)** – a Python package that subclasses Ableton’s `ControlSurface` class and implements the command queue and handlers.  It is installed into Ableton’s User Remote Scripts folder by the `--install` command【692402510651097†L18-L23】.
-2. **MCP server (`mcp_server`)** – a Python server built on the `fastmcp` framework.  It validates input parameters (ranges and types) before passing them to the remote script【608977690485721†L29-L34】.  Using a single TCP client avoids concurrency issues, because Ableton’s Live Object Model is not thread‑safe【665853537458845†L90-L97】.
-3. **CLI (JavaScript)** – the `npx` entry point uses Node.js to bootstrap the Python server and perform installation tasks.  The minimal `requirements.txt` lists `fastmcp` as the only runtime dependency【45077298533394†L0-L2】.
-4. **Docs and tests:** The repo contains a `docs/manual` folder with Markdown documentation, and it mentions a `tests` directory (run by `pytest`)【665853537458845†L110-L111】.
-
-While we cannot inspect individual functions, the combination of Python and Node indicates a hybrid architecture.  Using `fastmcp` suggests asynchronous I/O and structured validation.  The repository emphasises deterministic operations and explicit `undo` functionality【692402510651097†L63-L67】, which points to careful state management.  Including a detailed manual and CLI indicates strong attention to developer experience.
-
-## Comparison with other AI‑enabled Ableton assistants
-
-The AI‑DAW landscape has seen several community‑driven MCP servers that integrate language models with Ableton Live.  Below is a comparison of LivePilot with four notable open‑source alternatives and one machine‑learning plugin collection (Magenta Studio).  Star counts are ignored; only features matter.  All projects implement the MCP for connecting an AI client to Ableton, but they differ in language, feature set and design philosophy.
-
-### Feature comparison
-
-The table summarises the core capabilities (✓ = present, – = absent or not mentioned).  Note: only keywords/phrases are used in the cells; long prose is kept in the explanation below.
-
-| Tool/Project | Track & Session management | MIDI/Clip editing | Device/Effect control | Arrangement & automation | Mixing & routing | Browser search | Voice/audio generation | State rollback/Undo | Low‑latency/UDP | Autonomous agent |
-|---|---|---|---|---|---|---|---|---|---|---|
-| **LivePilot (dreamrec)** | create/delete/duplicate tracks, rename, color, mute, solo, arm【665853537458845†L45-L61】 | add/get/modify/duplicate/transpose/quantize notes【665853537458845†L62-L66】 | load instruments/effects, tweak parameters, rack chains, get presets【665853537458845†L66-L69】 | arrangement clip creation & full MIDI note CRUD, cue points, recording, timeline navigation【665853537458845†L74-L81】 | set volume, pan, sends; routing & return tracks; master control【665853537458845†L72-L74】 | search Ableton library & load presets【665853537458845†L72-L75】 | – (not in current version) | deterministic operations with undo/redo commands【692402510651097†L63-L67】 | – | built‑in producer agent via plugin【665853537458845†L82-L89】 |
-| **Ableton Copilot MCP (xiaolaa2)** | create/delete/duplicate/rename MIDI, audio & return tracks; set tempo, time signature and scale【477631886601640†L155-L160】 | add/remove/replace/duplicate notes, filter by pitch, transpose, adjust clip properties【477631886601640†L161-L166】 | browse library, load specific audio effects/instruments/VSTs, modify parameters, record audio into clips【477631886601640†L167-L171】 | – (no dedicated arrangement API mentioned) | – | – | – | robust state management with snapshot & rollback support【477631886601640†L173-L177】 | – | – |
-| **AbletonMCP (ahujasid)** | create/modify MIDI & audio tracks, load and configure remote script【260789399880945†L10-L16】 | create & edit MIDI clips; add notes【260789399880945†L14-L16】【260789399880945†L61-L63】 | select/load instruments & effects from Ableton’s browser【260789399880945†L13-L16】【260789399880945†L61-L63】 | – | basic playback/transport control【260789399880945†L15-L16】 | – | – | – (standard `undo` only) | – | – |
-| **Ableton Live MCP Server (Simon‑Kansara)** | generic track & session control via OSC【308870449054950†L16-L19】 | – | – | – | – | – | – | – | uses UDP/OSC for communication (requires separate daemon)【308870449054950†L30-L34】 | – |
-| **Ableton MCP Extended (uisato)** | comprehensive session & track management including group/folding states【795384148544515†L29-L35】 | create/rename clips; add/delete/transpose/quantize notes; batch edits【795384148544515†L35-L37】 | load instruments/effects; set & batch‑set parameters【795384148544515†L38-L41】 | automation/envelope editing; high‑performance mode using UDP for real‑time control【795384148544515†L41-L54】【795384148544515†L82-L87】 | volume, panning, mute, solo, sends【795384148544515†L29-L35】 | browse Ableton library and import audio files【795384148544515†L44-L46】 | voice/text‑to‑speech integration via ElevenLabs; custom voice & SFX【795384148544515†L47-L50】 | – (standard `undo` not emphasised) | ultra‑low latency via UDP server【795384148544515†L82-L87】 | – |
-| **Magenta Studio (Google)** | – | generates melodies/drums, extends or transforms patterns using ML models【262161962734483†L63-L84】 | – | – | – | – | – | – | – | – |
-
-### Discussion
-
-#### Breadth of control
-
-LivePilot stands out for its broad coverage of Ableton’s API.  It not only performs basic track and session operations but also supports **arrangement view editing** (creating arrangement clips, moving between cue points, starting/stopping recording, editing automation)【665853537458845†L74-L81】.  Most competitors focus on session view; for example, Ableton Copilot MCP’s documentation highlights track/clip manipulation and device control but does not mention arrangement or automation【477631886601640†L155-L171】.  AbletonMCP Extended adds some automation editing and envelope functionality【795384148544515†L41-L46】 but still doesn’t provide the same comprehensive list of arrangement tools.
-
-#### Mixing and browser integration
-
-LivePilot provides dedicated mixing tools (volume, pan, sends, routing, return tracks and master volume)【665853537458845†L72-L74】 and separate browser tools to search the entire Ableton library and load presets【665853537458845†L72-L75】.  The other projects have limited mixing commands; AbletonMCP Extended includes volume/panning/mute/solo and send control【795384148544515†L29-L35】, but others do not emphasise mixing.  Browser search appears in LivePilot and Extended; it is absent from Copilot MCP.
-
-#### Safety and robustness
-
-LivePilot emphasises deterministic operations and encourages the AI to verify the session state after every write.  The `undo` tool is exposed, making all destructive operations reversible【692402510651097†L63-L67】.  Ableton Copilot MCP goes further with **state rollback**; it snapshots the project state and can undo groups of operations, which is a robust safety net for complex tasks【477631886601640†L173-L177】.  Competitors built on Python sockets generally rely on Ableton’s own undo (a single step), so LivePilot’s explicit undo tool is a strength but could be improved by adopting a snapshot approach.
-
-#### Advanced features
-
-* **Autonomous agent:** LivePilot’s Claude plug‑in includes a **producer agent** that builds complete tracks from high‑level descriptions【665853537458845†L82-L89】.  None of the other open‑source projects advertise an autonomous composition agent, although some AI‑first DAW assistants outside the MCP ecosystem (e.g., commercial “Studio Co‑Pilot” or online generative services) may offer similar features.
-* **Voice and audio generation:** Ableton MCP Extended uniquely integrates ElevenLabs for voice/speech generation and allows direct import of generated audio into Ableton sessions【795384148544515†L47-L50】.  LivePilot lacks this type of generative audio; adding a similar feature could broaden its creative scope.
-* **Low‑latency control:** The Extended project includes a UDP server for ultra‑low‑latency parameter control【795384148544515†L82-L87】.  LivePilot uses a single TCP connection for thread safety【665853537458845†L90-L97】; while stable, it may introduce latency for real‑time performance.  Offering a high‑performance mode or MIDI mapping could appeal to live performers.
-* **State management:** Ableton Copilot MCP’s snapshot‑based rollback system is a notable innovation【477631886601640†L173-L177】.  LivePilot currently supports standard undo/redo but not multi‑step rollback; implementing such a feature would increase safety.
-* **Extensibility:** Both LivePilot and Ableton MCP Extended provide frameworks for creating custom tools.  LivePilot’s skill file teaches the AI how to interact correctly【692402510651097†L69-L81】, and the Extended project demonstrates building custom controllers (XY mouse controller)【795384148544515†L82-L87】.
-
-#### Installation and user experience
-
-LivePilot provides a simple `npx` installer and CLI commands to install, check status and run diagnostics【665853537458845†L22-L27】【665853537458845†L103-L106】.  Ableton Copilot MCP similarly offers one‑line installation via `npx @xiaolaa2/ableton-copilot-mcp --install-scripts`【477631886601640†L213-L216】.  AbletonMCP and Extended require cloning or using `uv` and copying remote scripts manually【260789399880945†L21-L34】【795384148544515†L56-L66】, which is less streamlined.  LivePilot’s documentation is thorough and includes a manual covering workflows, whereas competitors often rely on README‑level documentation or blog posts.
-
-### Strengths and areas for improvement
-
-#### Strengths of LivePilot
-
-1. **Comprehensive toolset:** With 91 tools covering transport, track management, clip operations, note editing, devices, scenes, mixing, browser search and arrangement, LivePilot offers the broadest feature coverage among existing MCP servers【665853537458845†L43-L70】.
-2. **Natural‑language workflows:** The manual demonstrates how to use conversation to build beats, search for instruments, program MIDI patterns and mix tracks【692402510651097†L39-L51】.  This conversational approach, combined with the producer agent, makes LivePilot accessible to users with minimal technical knowledge.
-3. **Deterministic operations and safety:** By mapping tools directly to Ableton’s API and exposing undo/redo, LivePilot aims to provide predictable outcomes and a clear safety net【608977690485721†L23-L27】【692402510651097†L63-L67】.
-4. **Developer experience:** The `npx` installer, CLI commands (`--status`, `--doctor`), cross‑platform support (macOS and Windows) and extensive manual contribute to a polished user experience【665853537458845†L103-L106】.
-5. **Plugin & agent integration:** The Claude plug‑in adds slash commands and an autonomous producer agent that can compose full tracks from high‑level prompts【665853537458845†L82-L89】.  This is unique among open‑source MCP servers.
-
-#### Areas for improvement
-
-1. **State rollback and history:** Competing projects like Ableton Copilot MCP implement snapshot‑based rollback【477631886601640†L173-L177】.  Incorporating multi‑step undo or versioned snapshots in LivePilot would improve safety during complex editing.
-2. **Voice and audio generation:** Ableton MCP Extended integrates ElevenLabs for text‑to‑speech and can import generated vocals or sound effects【795384148544515†L47-L50】.  Adding optional integration with generative audio tools (e.g., ElevenLabs, OpenAI TTS) could expand LivePilot’s creative capabilities.
-3. **Low‑latency control:** The Extended project’s UDP server provides ultra‑low‑latency parameter control【795384148544515†L82-L87】.  LivePilot could explore a similar performance mode or integration with hardware controllers to better serve live performers.
-4. **Simplify cross‑language architecture:** LivePilot uses Node.js to bootstrap a Python server; although this is hidden from the user, consolidating components or providing a purely Python installation could reduce complexity and dependency on Node.
-5. **Community engagement:** Many competing projects have active communities and Discord servers (e.g., AbletonMCP invites feedback on Discord【260789399880945†L8-L9】).  Building a community around LivePilot would encourage contributions, gather feedback and accelerate development.
-
-## Conclusion
-
-LivePilot is an ambitious and well‑documented project that aims to be a **comprehensive AI co‑pilot** for Ableton Live 12.  Its strength lies in its broad tool coverage, polished installation experience, deterministic operations and the inclusion of a plug‑in with an autonomous producer agent.  Compared with other MCP servers, LivePilot covers more domains (especially arrangement and mixing) and provides a more polished user experience.  Competing projects offer innovations such as state rollback, voice/audio generation and low‑latency control.  Incorporating similar features, encouraging community engagement and potentially simplifying the architecture would enhance LivePilot’s position as the most intelligent and versatile AI assistant for Ableton Live.