# Ableton MCP: server comparison and Claude or Codex setup

Choose an Ableton Live MCP server by edition and workflow. Compare Remote Scripts, Max for Live and Extensions, with setup and a first MIDI sketch.

Author: Anvisha Pai

Canonical: https://voyageragent.ai/blog/ableton-mcp

Published: 2026-09-17
Updated: 2026-09-17

![A home studio at night: a laptop showing a grid of coloured clip slots, a pad controller, a small keyboard, studio monitors, and a small green terminal screen beside them under a desk lamp.](https://cdn.moda.app/voyager/blog/ableton-mcp/hero-f3b938d0b4.webp)

To let an agent change an Ableton Live Set, use a community bridge matched to your edition. The official Claude connector answers from Live documentation; it does not edit a Set. Remote Script servers and Max for Live devices provide different routes into the application, while the Extensions SDK is a newer beta option.

For a first experiment, use a blank Set and ask for a short MIDI clip on one track. Confirm the notes before asking for arrangement or mixing changes. The comparisons below use repository and vendor documentation checked on 17 September 2026; the sketch is a suggested walkthrough, not an independently recorded performance test.

**Jump to:** [setup](#setup-verified-against-the-docs) · [edition requirements](#the-routes-at-a-glance) · [servers](#the-community-servers-checked-on-17-september-2026) · [first sketch](#a-first-sketch-to-try)

## Setup, verified against the docs

### ahujasid/ableton-mcp with Claude Code

1. Install [uv](https://docs.astral.sh/uv/); the server runs as `uvx ableton-mcp`.
2. Install the Remote Script with `uvx --from ableton-mcp ableton-mcp-install-script`, which reads the User Library location from Live's `Library.cfg` and copies the script into `Remote Scripts` ([README](https://github.com/ahujasid/ableton-mcp)).
3. Restart Live. In Preferences > Link, Tempo & MIDI, pick AbletonMCP in a Control Surface slot; the status bar should report port 9877.
4. Register the server: `claude mcp add --transport stdio AbletonMCP -- uvx ableton-mcp`. The `--` keeps Claude Code from parsing the command as its own options, `--scope project` writes it to `.mcp.json` instead of your user config, and `--env ABLETON_MCP_DISABLE_TELEMETRY=true` before `--transport` turns off telemetry ([Claude Code MCP docs](https://code.claude.com/docs/en/mcp)).
5. Run `claude mcp list` or `/mcp` to confirm, then ask for `get_session_info` before anything that writes.

The README warns to run only one instance of the server at a time, so disconnect Claude Desktop while Claude Code is in use.

### Producer Pal with Codex

1. Download `Producer_Pal.amxd` and drop it on a MIDI track in Live 12.3 or later with Max for Live ([installation guide](https://producer-pal.org/installation)).
2. With Node 20 or later installed, run `codex mcp add producer-pal -- npx -y producer-pal@latest`. Codex writes a `[mcp_servers.producer-pal]` block to `~/.codex/config.toml`, shared by the CLI, the IDE extension and the ChatGPT desktop app ([Codex MCP docs](https://learn.chatgpt.com/docs/extend/mcp?surface=cli)).
3. For HTTP instead, `codex mcp add producer-pal --url http://localhost:3350/mcp`; Live must already be running and the connection does not reconnect on its own ([producer-pal.org](https://producer-pal.org/installation/other-mcp)). `codex mcp list` confirms the entry.

The same pattern applies to LivePilot (`npx livepilot --setup` writes the client config), wstierhout's server (`uvx mcp-server-ableton-live@1.8.1`) and any other stdio server in the table.

## The routes at a glance

| Route                         | What it is                                                                                        | Edition                                          | Best for                                                                         |
| ----------------------------- | ------------------------------------------------------------------------------------------------- | ------------------------------------------------ | -------------------------------------------------------------------------------- |
| Anthropic's Ableton connector | Official, documentation-grounded answers in Claude; no Set access                                 | Any (it never touches Live)                      | Learning Live, writing Max for Live or Remote Script code                        |
| Remote Script servers         | A Python control surface script inside Live opens a localhost socket; an MCP server talks to it   | Intro, Standard, Suite (Live 10 or 11 and later) | Session scaffolding, MIDI clips, device loading, parameter tweaks                |
| Max for Live servers          | An `.amxd` device hosts the MCP server in Node for Max and reaches the Live Object Model directly | Suite only                                       | The same jobs, with Max for Live installed and no Remote Script folder to manage |
| Extensions SDK servers        | An `.ablx` extension runs in Live's Node-based Extension Host and opens a local endpoint          | Suite beta 12.4.5 or later                       | Early adopters on the beta; the only official app-level API                      |
| AbletonOSC and ableton-js     | Remote Scripts that expose the Live API over OSC or WebSocket, for any language                   | Intro, Standard, Suite                           | Building your own bridge, generative scripts                                     |
| MIDI files                    | The agent writes a `.mid` file; you drag it in                                                    | Any, including Lite                              | No install, no socket, nothing running inside Live                               |
| ALS project editing           | Reading or rewriting the gzipped XML of a `.als` file with Live closed                            | Any                                              | Batch audits of many projects; risky for writes                                  |
| Agent skills                  | Instructions and references that make any of the above produce better calls                       | Any                                              | Pairing with a server, or with the Extensions SDK                                |
| Screen control                | Computer-use tools driving the GUI by screenshot                                                  | Any                                              | The few things no API reaches                                                    |

## What Ableton itself provides

### The Claude connector: documentation, not control

On 28 April 2026 Anthropic announced nine creative-tool connectors, including one for Ableton that "grounds Claude's answers in official product documentation for Live and Push" and a Splice connector that searches its sample catalog from within Claude ([Anthropic](https://www.anthropic.com/news/claude-for-creative-work)). The connector does not see your Set, cannot create a track, and runs nothing on your machine. It is useful for Push workflows, device questions, and drafting the Max for Live or Remote Script code the routes below depend on.

### The Extensions SDK: Ableton's first app-level API, in beta

The larger news is the Extensions SDK, announced on Ableton's blog on 2 June 2026 as "an open JavaScript toolkit allowing anyone to create custom tools that expand the possibilities inside Live 12 Suite" ([Ableton blog](https://www.ableton.com/en/blog/introducing-extensions-sdk/)). Extensions ship as `.ablx` files, install from Settings > Extensions, and run in a Node.js Extension Host; they can "interact with tracks, clips, MIDI, devices, tempo, and other parts of a Live Set" ([Extensions FAQ](https://help.ableton.com/hc/en-us/articles/27303428331420-Ableton-Extensions-FAQ)). Three constraints matter for agents:

* **Suite beta only.** "Extensions are available in Live 12 Suite Beta, version 12.4.5 or later. Extensions are not available in Live Standard, Intro, or Lite" ([Ableton](https://www.ableton.com/en/live/extensions/)). The public release notes reached 12.4.6 on 15 September 2026 with no Extensions entry, while the beta notes at 12.4.15b3 a day later still list SDK fixes ([release notes](https://www.ableton.com/en/release-notes/live-12/), [beta notes](https://www.ableton.com/en/release-notes/live-12-beta/)).
* **One-shot by design.** Extensions "are intended for discrete tasks that are completed and closed after a single use" and "are not designed for continuous, real-time, or signal-processing tasks", which rules out audio effects, live MIDI transformation, background analysis and "real-time interaction with transport" ([Extensions FAQ](https://help.ableton.com/hc/en-us/articles/27303428331420-Ableton-Extensions-FAQ)). A server that keeps an endpoint open inside the host is working against that grain.
* **Ableton's own security line.** The FAQ says the Node platform "comes with the risk of third parties creating malicious Extensions with ill intent. As with any software you download from the internet, exercise caution and make sure you trust the source." A 12.4.5b5 change added a confirmation dialog on install.

![Ableton's Extensions page: the headline Break what's expected, Make Live your own, a TypeScript file called My\_First\_Extension.ts importing from @ableton-extensions/sdk, an .ablx file icon, and a banner saying Extensions run on the Live 12 beta program.](https://cdn.moda.app/voyager/blog/ableton-mcp/fig-extensions-7c05d93706.webp)

Ableton's first documented API for the Set itself. The banner in the corner is the constraint: beta program, Suite licence.

Ableton mentions neither agents nor MCP on these pages, only that the SDK "is built on standard web technologies that AI coding assistants handle well". The most-starred SDK repository on GitHub is a skill that teaches a coding agent to build extensions ([Ronvaknins/ableton-extensions-skill](https://github.com/Ronvaknins/ableton-extensions-skill), 80 stars).

## The two layers under every community server

### MIDI Remote Scripts: Python inside Live, undocumented

Live loads Python control surface scripts from a `Remote Scripts` folder in the User Library (`~/Music/Ableton/User Library` on macOS, `Documents\Ableton\User Library` on Windows) and lists them in Preferences > Link, Tempo & MIDI under Control Surface ([Ableton help](https://help.ableton.com/hc/en-us/articles/209072009-Installing-third-party-remote-scripts)). The same article says Live 11 moved scripts from Python 2 to 3 and that "we cannot provide technical support for remote scripts not included with Live." Ableton has never published a reference for the framework; the community works from extracted sources such as Julien Bayle's Live 12.4 scripts ([gluon/AbletonLive12\_MIDIRemoteScripts](https://github.com/gluon/AbletonLive12_MIDIRemoteScripts), 162 stars) and his reference site, which puts Live 11 on Python 3.7 and Live 12 on 3.11 ([midiremotescripts.structure-void.com](https://midiremotescripts.structure-void.com/)).

A Remote Script has full access to the Live API and to Python's standard library, which is how the MCP servers work: the script opens a TCP socket, the MCP process outside Live sends JSON, and the script executes calls on Live's main thread. Widest edition support, least official footing.

### The Live Object Model through Max for Live

The Live Object Model is the documented hierarchy of Application, Song, Track, ClipSlot, Clip, Device and DeviceParameter objects. Cycling '74 maintains the reference, stated against Live 12.1, and the Max objects that touch it: `live.path` navigates to an object, `live.object` gets and sets its properties and calls its functions, `live.observer` watches a property, and `live.remote~` streams values into a parameter in real time; the `js` object exposes the same API to JavaScript ([Cycling '74 LOM](https://docs.cycling74.com/max8/vignettes/live_object_model), [Live API overview](https://docs.cycling74.com/userguide/m4l/live_api_overview/)). A device can also run Node for Max, so it can host an entire MCP server and speak to the LOM from one process. The cost is the edition: Max for Live is a Suite feature ([compare editions](https://www.ableton.com/en/live/compare-editions/)).

![Cycling '74's LOM, The Live Object Model page: an introduction describing the Live object classes, their properties and functions and parent-child relations, a note that the document refers to Ableton Live version 12.1, and a table of contents listing Application, Song, Track, ClipSlot, Clip, Device and more.](https://cdn.moda.app/voyager/blog/ableton-mcp/fig-lom-4c246f6799.webp)

The one properly documented map of what is reachable inside a Set. Remote Script servers and AbletonOSC mirror this hierarchy without the documentation.

## The community servers, checked on 17 September 2026

A GitHub search for "ableton mcp" returns 208 repositories. The table has every one with a distinct bridge, more than fifty stars, or a recent push and something the others lack. Stars and last push are from the GitHub API on the day of writing; tool counts are the repositories' own claims.

| Repository                                                                                        | Stars | Last push   | Bridge                                                              | Tools                                                  | Requirements                                   | Notes                                                                 |
| ------------------------------------------------------------------------------------------------- | ----- | ----------- | ------------------------------------------------------------------- | ------------------------------------------------------ | ---------------------------------------------- | --------------------------------------------------------------------- |
| [ahujasid/ableton-mcp](https://github.com/ahujasid/ableton-mcp)                                   | 3,067 | 30 Aug 2026 | Remote Script, TCP 9877                                             | 37                                                     | Live 10+, Python 3.8+, uv                      | MIT. The reference implementation; 412 forks; telemetry on by default |
| [Simon-Kansara/ableton-live-mcp-server](https://github.com/Simon-Kansara/ableton-live-mcp-server) | 394   | 26 Mar 2025 | AbletonOSC, UDP 11000/11001                                         | Maps OSC addresses to tools                            | AbletonOSC installed                           | MIT. No push in 18 months                                             |
| [adamjmurray/producer-pal](https://github.com/adamjmurray/producer-pal)                           | 297   | 15 Sep 2026 | Max for Live device, HTTP on localhost:3350                         | Tracks, clips, devices, arrangement, REST API          | Live 12.3+ with Max for Live, 12.4 recommended | GPL-3.0. Stdio via `npx -y producer-pal@latest`                       |
| [uisato/ableton-mcp-extended](https://github.com/uisato/ableton-mcp-extended)                     | 267   | 7 May 2026  | Remote Script, TCP plus UDP                                         | Automation, browser, ElevenLabs voice                  | Live 11+, Python 3.10+                         | MIT. Automation "isn't working perfectly yet"                         |
| [bschoepke/ableton-live-mcp](https://github.com/bschoepke/ableton-live-mcp)                       | 224   | 25 Jul 2026 | Remote Script that evaluates Python inside Live                     | Task tools plus arbitrary Python; Audio Tap M4L device | Tested on Suite 12.3.8, macOS                  | MIT. "Back up your Live Set before using this"                        |
| [xiaolaa2/ableton-copilot-mcp](https://github.com/xiaolaa2/ableton-copilot-mcp)                   | 92    | 29 Jul 2026 | ableton-js, WebSocket                                               | Song, track, MIDI, audio recording, rollback for notes | Live 12 (tested 12.1.10)                       | MIT. Arrangement View operations                                      |
| [dreamrec/LivePilot](https://github.com/dreamrec/LivePilot)                                       | 69    | 17 Sep 2026 | Remote Script, TCP 9878; optional M4L bridge                        | 474 across 57 domains, 26 exposed at connect           | Live 12+, Python 3.12+, Node 18+               | BUSL-1.1. `.mcpb` for Claude Desktop, spectral analysis               |
| [jpoindexter/ableton-mcp](https://github.com/jpoindexter/ableton-mcp)                             | 53    | 1 May 2026  | Remote Script, TCP 9877; also M4L chat and REST                     | 200+                                                   | Live 10+, Python 3.8+                          | MIT. Ollama, OpenAI, Groq                                             |
| [fadelabs/phantom](https://github.com/fadelabs/phantom)                                           | 35    | 7 Sep 2026  | ahujasid's bridge, locked to localhost                              | 20 analysis tools plus 5 Claude Code skills            | macOS or Linux, Python 3.10 to 3.13            | AGPL-3.0. Loudness, masking, reference matching on exported audio     |
| [OthmanAdi/loophole](https://github.com/OthmanAdi/loophole)                                       | 19    | 13 Sep 2026 | Extensions SDK `.ablx`, HTTP and SSE on 127.0.0.1 with bearer token | 12                                                     | Live 12.4.5 Suite beta                         | MIT. No Remote Script, no Max                                         |
| [jasper-zheng/ableton-sdk-mcp](https://github.com/jasper-zheng/ableton-sdk-mcp)                   | 19    | 15 Jun 2026 | Extensions SDK, WebSocket 127.0.0.1:17890                           | 7, incl. `ableton_run_code` executing TypeScript       | Live 12.4.5+, Developer Mode, Node 24+         | Runs agent-written code against the SDK                               |
| [wstierhout/ableton-live-mcp](https://github.com/wstierhout/ableton-live-mcp)                     | 17    | 17 Sep 2026 | Remote Script, 127.0.0.1:9877 loopback only                         | 156 typed, plus offline `.als` inspection              | Live 11 or 12, Python 3.10+                    | MIT. `uvx mcp-server-ableton-live@1.8.1`                              |
| [Ziforge/ableton-liveapi-tools](https://github.com/Ziforge/ableton-liveapi-tools)                 | 16    | 9 Sep 2026  | Remote Script, TCP 9004, JSON                                       | About 220                                              | Live 11 or 12, Intro to Suite                  | GPL-3.0. A socket API to wrap, not an MCP server itself               |
| [nozomi-koborinai/ableton-osc-mcp](https://github.com/nozomi-koborinai/ableton-osc-mcp)           | 11    | 6 Sep 2026  | AbletonOSC                                                          | OSC wrapper                                            | AbletonOSC installed                           | MIT. The maintained OSC option                                        |
| [romsau/agent4live](https://github.com/romsau/agent4live)                                         | 6     | 16 May 2026 | Max for Live device hosting Node MCP server, bearer token           | 230 across 13 families                                 | Live 12 Suite, Max 9, macOS                    | MIT. Auto-registers with Claude Code, Gemini CLI, OpenCode            |

Four readings.

**One server is the default, and its maintenance is thin.** ahujasid/ableton-mcp has 3,067 stars and 412 forks, ten times the next Remote Script project, but only 70 commits in eighteen months, 27 open pull requests, and a design unchanged since March 2025: a `ControlSurface` subclass binding a socket on port 9877 and a Python server sending JSON to it. It works, it is simple to read, and several rows above extend it.

![The ahujasid/ableton-mcp repository on GitHub: 3.1k stars, 412 forks, 70 commits, 19 contributors, MIT licence, two folders named AbletonMCP\_Remote\_Script and MCP\_Server, and a TERMS.md file describing telemetry.](https://cdn.moda.app/voyager/blog/ableton-mcp/fig-ahujasid-13c87abe32.webp)

The reference implementation. Two folders are the whole architecture: the Remote Script that runs inside Live and the MCP server that runs outside it.

**The most-starred OSC server is abandoned.** Simon-Kansara's has not been pushed since 26 March 2025. AbletonOSC, the Remote Script it depends on, is healthier (807 stars, MIT, ports 11000 and 11001, Live 11 and later, an API that mirrors the LOM naming) but was last pushed on 19 November 2025 ([AbletonOSC](https://github.com/ideoforms/AbletonOSC)). For OSC, nozomi-koborinai's wrapper is the one with a September push.

**The Max for Live route has the deepest project.** Producer Pal is a GPL-3.0 Max for Live device with nearly seven thousand commits, its own documentation site, a REST API on the same port, an agent skill for Claude Code, Codex CLI and Gemini CLI, and stdio through `npx -y producer-pal@latest` so the client can start before Live does ([producer-pal.org](https://producer-pal.org/installation/other-mcp)). It needs Live 12.3 or later with Max for Live, so Suite ([installation guide](https://producer-pal.org/installation)).

![The Producer Pal website: Control Ableton Live with words, the open Ableton MCP server and REST API, works with Claude, Gemini, ChatGPT and Ollama, free and open source, with buttons to download the Max for Live device, a Claude Desktop extension and npx producer-pal.](https://cdn.moda.app/voyager/blog/ableton-mcp/fig-producer-pal-f0abb81a7d.webp)

The Max for Live route. One device on one track hosts the whole server; the trade is a Suite licence for no Remote Script folder.

**Tool counts are a design choice.** LivePilot claims 474 tools and shows the client 26 plus a search tool, because a context window full of schemas is a cost. bschoepke's server and jasper-zheng's Extensions server hand the agent an interpreter instead: Python inside Live in one case, TypeScript against the SDK in the other. For a coding agent that can read a reference, "run this code" plus a few typed reads beats hundreds of thin wrappers.

## The routes with no MCP server

**Plain MIDI files.** Every edition of Live, including Lite, imports Standard MIDI files: "MIDI file data is incorporated into the Live Set", by dragging from the browser or with Create > Import MIDI File, and any clip exports again with File > Export MIDI Clip ([Live manual](https://www.ableton.com/en/manual/managing-files-and-sets/)). An agent with a shell and [mido](https://github.com/mido/mido) (1,639 stars, MIT) can write a drum pattern, a bass line and a chord progression as `.mid` files with nothing installed in Live. What you lose is everything after the notes: instruments, devices, mixer, arrangement.

**AbletonOSC and ableton-js as raw surfaces.** Both are Remote Scripts that expose the Live API to any language: OSC on UDP 11000 and 11001 for AbletonOSC, a WebSocket on `127.0.0.1:39031` with optional HMAC authentication for ableton-js (526 stars, pushed 15 September 2026, Live 11 and later) ([ableton-js](https://github.com/leolabs/ableton-js)). An agent that can write a script does not strictly need an MCP server on top.

**Ableton Link is not a control route.** Link "synchronizes musical beat, tempo, and phase across multiple applications running on one or more devices", plus start and stop since version 3 ([Link docs](https://ableton.github.io/link/)). It carries no MIDI, audio or track state; it matters only if an agent-driven sequencer outside Live must stay in time with Live.

**ALS project files.** A `.als` Set is gzip-compressed XML. The one MCP server built on that is read-only by design: closestfriend/ableton-proj-mcp scans folders of Sets with Live closed for missing samples, plugin usage and duplicate projects, and "cannot extract MIDI data, waveforms, or plugin parameters" ([ableton-proj-mcp](https://github.com/closestfriend/ableton-proj-mcp)). Writing the XML back is unsupported: the schema is undocumented, changes between versions, and a Set that Live refuses to open has no undo.

**Agent skills.** [glincker/ableton-skills](https://github.com/glincker/ableton-skills) (29 stars, MIT, pushed 24 August 2026) ships twelve skills and four slash commands for Claude Code, Cursor, Codex CLI and Gemini CLI covering mixing diagnostics, humanisation, arrangement and sidechain routing, and states that it requires a separate server, recommending uisato's or ahujasid's. Phantom and Producer Pal ship their own. None do anything alone; they make whichever server you chose produce better calls.

**Screen control.** Anthropic's computer use tool gives Claude "screenshot capabilities and mouse/keyboard control", recommends "a dedicated virtual machine or container with minimal privileges", and warns that "Claude will follow commands found in content even when they conflict with your instructions" ([Anthropic docs](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool)). Live in a minimal VM is not a production setup. Keep it for one step with no API, such as a third-party plugin's window.

## A first sketch to try

The prompt is "122 BPM, a four-bar drum pattern with a kick on every beat and a clap on 2 and 4, a G minor root-fifth bass line, load a drum kit and a bass synth, and play it." With ahujasid's server, the calls are these, named as in the server source:

1. `get_session_info` to learn what already exists, so it does not create tracks on top of yours.
2. `set_tempo(122)`.
3. `create_midi_track(-1)` twice, then `set_track_name` for "Drums" and "Bass".
4. `get_browser_tree` and `get_browser_items_at_path` to find a kit and a bass preset, because the load tools take browser URIs, not names; then `load_drum_kit` and `load_instrument_or_effect`.
5. `create_clip(track_index, clip_index, length=4.0)` on each track, then `add_notes_to_clip` with a list of notes, each a dictionary of pitch, start time in beats, duration, velocity and mute: sixteen kicks at pitch 36 and eight claps at 39 for the drums, G1 and D2 alternating in eighths for the bass.
6. `fire_clip` on both, or `start_playback`.
7. `get_session_snapshot` to confirm the notes landed.

Version limits show here too: `create_audio_clip` in the same server calls a `ClipSlot.create_audio_clip` API that "was introduced in 12.0.5", so importing audio needs Live 12 while everything above runs on Live 10 and 11. And the README's note that the tool "is designed to work with Ableton's default devices and browser items" is the ceiling: a third-party synth exposes parameters, but its presets and its own UI are out of reach.

## Which route for which job

| Job                                                                                   | Route                                                        | Why                                                            |
| ------------------------------------------------------------------------------------- | ------------------------------------------------------------ | -------------------------------------------------------------- |
| Learn a device, a Push workflow, or how to write a Remote Script                      | Anthropic's connector, or the Extensions FAQ                 | Documentation grounding is what it is for                      |
| Scaffold a session: tempo, tracks, names, colours, instruments from the stock library | ahujasid or wstierhout (Remote Script), Producer Pal (Suite) | Well covered, low risk, easy to inspect afterwards             |
| Write drum, bass and chord clips into slots                                           | Any Remote Script or Max for Live server                     | The LOM's note API is complete and every server wraps it       |
| Generate patterns with no install at all                                              | MIDI files with mido                                         | Works on Lite, nothing runs inside Live                        |
| Arrangement View work, audio recording, rollback of note edits                        | ableton-copilot-mcp, LivePilot                               | The only servers that document arrangement and recording tools |
| Measure loudness, masking, tonal balance, compare to a reference                      | Phantom, LivePilot's analysis, bschoepke's Audio Tap         | Analysis runs on exported or tapped audio, outside the LOM     |
| Give the agent an interpreter and a reference instead of tools                        | bschoepke (Python), jasper-zheng (TypeScript, beta)          | Fewer schemas, more reach, more risk                           |
| Stay on the official API                                                              | Loophole or ableton-sdk-mcp on the Suite beta                | Beta-only, one-shot design, gaps in automation and routing     |
| Audit fifty old projects for missing samples and plugins                              | ableton-proj-mcp                                             | Read-only ALS parsing with Live closed                         |
| Keep an external sequencer in time with Live                                          | Ableton Link                                                 | Sync only; no control                                          |
| Cursor, Codex, Gemini CLI, local models                                               | Producer Pal, LivePilot, or any stdio server                 | All are plain stdio or localhost HTTP                          |
| A plugin's own window, a warp marker, a dialog                                        | Screen control, or your own hands                            | No API exists                                                  |

## Maturity and security, honestly

What works: reading a Set, creating and naming tracks, writing MIDI clips with exact notes, loading stock instruments and effects by browser path, setting device parameters, changing tempo, firing clips, and in the newer servers placing clips in the Arrangement and recording audio. A session that would take fifteen minutes of clicking takes one prompt, and the result is ordinary Live objects you can edit.

What does not work, or not well: automation envelopes (uisato's README says so), third-party plugin presets, anything inside a plugin's UI, freezing and exporting (wstierhout's README lists them as manual because the API lacks them), and any judgement that needs ears. A server can report that a track peaks at minus 0.3 dBFS; it cannot hear that the kick and bass are fighting, and the mix decision is still yours. Timing-critical work is out by construction: Ableton's FAQ excludes real-time tasks from Extensions, and a Remote Script parsing JSON on Live's main thread is no place for anything that must land on the grid.

Failure modes are specific. A modal dialog in Live blocks a Remote Script until someone dismisses it. Some servers replace clip contents in ways Live's undo does not cover: ableton-copilot-mcp warns that "direct manipulation of MIDI clips by AI may result in the loss of original notes and cannot be undone with Ctrl + Z", and bschoepke's opens with "Back up your Live Set before using this."

Four security points.

* **A Remote Script is arbitrary Python inside Live.** It runs with your user's permissions, has the full standard library, and Ableton neither reviews nor supports it. Read the script before you install it; ahujasid's is one file.
* **Check the bind address.** ahujasid's Remote Script binds `0.0.0.0:9877`, so any machine on your network can send it commands; wstierhout's binds `127.0.0.1` and says "do not forward that port", and Phantom's installer rewrites the ahujasid script to localhost for this reason. agent4live and Loophole add a bearer token.
* **Telemetry.** ahujasid's server has telemetry "on by default" and its tool signatures carry a `user_prompt` argument described in the source as "the original user prompt that led to this tool call (for telemetry)". Set `ABLETON_MCP_DISABLE_TELEMETRY=true` if your prompts describe unreleased work.
* **Your Set goes to the model.** Track names, clip names, device chains and notes are sent to whichever model you use, which matters for sessions under NDA.

## Frequently asked questions

**Does Ableton have an MCP server?** There are community servers, but no official Ableton control server in the sources reviewed here. Ableton has an Extensions SDK in the Live 12 Suite beta, an official JavaScript API that community developers have wrapped as MCP servers, and Anthropic has a Claude connector that answers from Live's documentation without touching a Set. Every server that controls Live is a community project.

**Can Claude control Ableton Live?** Yes, through a community server. The best-known is ahujasid/ableton-mcp, a Remote Script plus a Python server for Claude Desktop, Claude Code and Cursor on Live 10 and later; Producer Pal does the same through a Max for Live device on Live 12.3 Suite and up. The official connector cannot.

**Is there an Ableton API?** Three, in practice. The Live Object Model is documented by Cycling '74 and reached through Max for Live, which needs Suite. MIDI Remote Scripts reach the same objects from Python inside Live in any full edition, undocumented and unsupported. The Extensions SDK is Ableton's first documented app-level API: JavaScript, beta, Suite only.

**Does it work with Live Lite or Intro?** Remote Script servers list Intro among supported editions, so Intro should work for those routes. Max for Live and Extensions routes are Suite only. Lite is not on Ableton's edition comparison and no server README claims it; treat Lite as untested and use MIDI files, which import into every edition.

**Is it free?** Licences differ: most listed servers use MIT, Producer Pal uses GPL-3.0 and Phantom uses AGPL-3.0. LivePilot uses the Business Source License, which is source-available rather than a standard open-source licence. You pay for the model through an API key or a Claude, ChatGPT, Cursor or Codex subscription, and for Live: Suite if you want the Max for Live or Extensions routes. The SDK itself is free.


## Make your next project in Voyager

Create an account, download Voyager, and start making.

[Sign up](/sign-up)