LivePilot

██╗     ██╗██╗   ██╗███████╗██████╗ ██╗██╗      ██████╗ ████████╗
██║     ██║██║   ██║██╔════╝██╔══██╗██║██║     ██╔═══██╗╚══██╔══╝
██║     ██║██║   ██║█████╗  ██████╔╝██║██║     ██║   ██║   ██║
██║     ██║╚██╗ ██╔╝██╔══╝  ██╔═══╝ ██║██║     ██║   ██║   ██║
███████╗██║ ╚████╔╝ ███████╗██║     ██║███████╗╚██████╔╝   ██║
╚══════╝╚═╝  ╚═══╝  ╚══════╝╚═╝     ╚═╝╚══════╝ ╚═════╝    ╚═╝

AI copilot for Ableton Live 12 — 104 MCP tools for music production, sound design, and mixing.

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.

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.

Agent & Technique Memory

LivePilot is stateless by default — 104 tools, deterministic execution, no hidden context. The agent layer adds persistent state on top: a technique memory system that stores production decisions as typed, searchable, replayable data structures with structured metadata.

How it works

The memory system stores five technique types: beat_pattern, device_chain, mix_template, preference, and browser_pin. Each technique consists of three layers:

When you save a technique, the agent collects raw data from Ableton using existing tools (get_notes, get_device_parameters, etc.) and writes a structured qualities analysis. The qualities are what make search useful — memory_recall(query="dark heavy 808") matches against mood, genre tags, sonic texture, and summary fields, not just names.

Three operating modes

The agent consults memory by default but never constrains itself to it. Override is always one sentence away.

Replay architecture

memory_replay does not execute Ableton commands directly. It returns a structured plan — an ordered list of tool calls (search_browser, load_browser_item, create_clip, add_notes, etc.) that the agent then executes through the existing MCP tools. This keeps the memory system decoupled from the Ableton connection and makes replay logic testable without a running DAW.

Building the corpus over time

The shipped plugin includes a reference corpus (~2,700 lines): genre-specific drum patterns, chord voicings, sound design recipes, mixing templates, and workflow patterns. This is the baseline — the agent is competent from the first session.

The technique memory extends this with user-specific data. As you save techniques, rate them, and tag them, the library becomes a structured representation of your production preferences. The agent reads across saved qualities at decision time — not to copy stored patterns, but to understand tendencies: swing ranges, kit preferences, harmonic language, arrangement density. New output is always generated; the memory informs the generation.

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 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 across all track types including return tracks and master. Run diagnostics to catch silent tracks and stale solos
• Remember and evolve — Save techniques, build a personal style library, and let the agent learn your taste over time
• Iterate fast — Transpose, humanize, quantize, duplicate, and reshape patterns through conversation

Quick Start

1. Install the Remote Script

npx -y github:dreamrec/LivePilot --install

2. Enable in Ableton

Restart Ableton Live, then go to Preferences > Link, Tempo & MIDI > Control Surface and select LivePilot.

3. Add to your MCP client

claude mcp add LivePilot -- npx -y github:dreamrec/LivePilot

{
  "mcpServers": {
    "LivePilot": {
      "command": "npx",
      "args": ["-y", "github:dreamrec/LivePilot"]
    }
  }
}

claude plugin add github:dreamrec/LivePilot/plugin

{
  "mcpServers": {
    "LivePilot": {
      "command": "npx",
      "args": ["-y", "github:dreamrec/LivePilot"]
    }
  }
}

npm install -g github:dreamrec/LivePilot
livepilot --install

{
  "mcpServers": {
    "LivePilot": {
      "command": "livepilot"
    }
  }
}

{
  "mcpServers": {
    "LivePilot": {
      "command": "npx",
      "args": ["-y", "github:dreamrec/LivePilot"]
    }
  }
}

{
  "servers": {
    "LivePilot": {
      "command": "npx",
      "args": ["-y", "github:dreamrec/LivePilot"]
    }
  }
}

{
  "mcpServers": {
    "LivePilot": {
      "command": "npx",
      "args": ["-y", "github:dreamrec/LivePilot"]
    }
  }
}

4. Verify connection

npx -y github:dreamrec/LivePilot --status

104 Tools Across 10 Domains

Plugin

The plugin adds a skill, an autonomous agent, and 5 slash commands on top of the MCP tools.

claude plugin add github:dreamrec/LivePilot/plugin

Commands

Producer Agent

Autonomous agent that executes multi-step production tasks from high-level descriptions. Handles the full pipeline: session planning, track creation, instrument loading, MIDI programming, effect configuration, and mixing — with mandatory health checks between each stage to verify every track produces audible output.

The agent ships with a 2,700-line reference corpus covering genre-specific drum patterns, chord voicings, sound design parameter recipes, mixing templates, and song structures. It consults the technique memory by default (see above), and can be overridden to work from a clean slate.

Core Skill

livepilot-core encodes operational discipline for the 104 tools: read state before writing, verify after every mutation, validate instrument loading (empty Drum Racks produce silence), never hallucinate device names (always search_browser first), use negative track indices for return tracks. Without it, an LLM with access to the tools will produce silent tracks and load wrong devices.

The Landscape

There are 15+ MCP servers for Ableton Live as of March 2026. Here's how the major ones compare:

At a Glance

Feature Comparison

Also Notable

• Simon-Kansara (369★) — OSC-based, exhaustive address mapping, inactive since 2025
• jpoindexter — 200+ tools, triple interface (MCP + REST + M4L), 13 scales
• cafeTechne — 220+ tools, Windows/Codex optimized, Live 11 focused
• FabianTinkl — AI-powered chord/melody generation, genre-specific composition
• nozomi-koborinai — Only Go implementation, uses Google Genkit

Where LivePilot Fits

LivePilot is the only server that ships as a complete production system — not just tools, but an AI plugin with skills, an autonomous producer agent, technique memory, and a built-in knowledge base of 280+ devices. It's designed for Live 12's modern API (per-note probability, arrangement automation, plugin browser) and wraps every mutation in undo blocks.

AbletonBridge has more raw tools (322 vs 104). Producer Pal has the easiest install (drag a .amxd). The original AbletonMCP has the community (2.3k stars). LivePilot has the deepest integration — it doesn't just expose the API, it teaches the AI how to use it.

Architecture

AI Client
       │ MCP Protocol (stdio)
       ▼
┌─────────────────────┐
│   MCP Server        │  Python (FastMCP)
│   mcp_server/       │  Input validation, auto-reconnect
└────────┬────────────┘
         │ JSON over TCP (port 9878)
         ▼
┌─────────────────────┐
│   Remote Script     │  Runs inside Ableton's Python
│   remote_script/    │  Thread-safe command queue
│   LivePilot/        │  ControlSurface base class
└─────────────────────┘

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.

Compatibility

Requirements: Ableton Live 12 · Python 3.9+ · Node.js 18+

CLI

npx livepilot              # Start MCP server (stdio)
npx livepilot --install    # Install Remote Script
npx livepilot --uninstall  # Remove Remote Script
npx livepilot --status     # Check Ableton connection
npx livepilot --doctor     # Full diagnostic check
npx livepilot --version    # Show version

Documentation

Read the full manual — Getting started, tool reference, production workflows, MIDI programming, sound design, mixing, and troubleshooting.

Development

git clone https://github.com/dreamrec/LivePilot.git
cd LivePilot
python3 -m venv .venv
.venv/bin/pip install -r requirements.txt
.venv/bin/pytest tests/ -v

Contributing

Contributions welcome. Please open an issue first to discuss what you'd like to change.

License

MIT — Pilot Studio