LiveBridge

Originally created by Valentijn (valentijnh/livebridge-ableton-mcp), developed further here by morpheasgr. This version adds the optional Max for Live devices (LiveBridge Engine and LiveBridge MIDI: real-time listening, A/B and masking while playing, captures, live modulation, follow actions, MIDI input, faster automation recording), sample and plug-in search across Live's browser, arrangements that keep their automation, production know-how (genres, Serum 2, workflows), a sound library, generative notes and session memory. Website: https://morpheasgr.github.io/livebridge-ableton-mcp/

You: Make an 8-bar house beat at 124 BPM: a 909 kit, an off-beat sub bass on Am–F–C–G and a warm pad playing the chords. Keep the levels sensible.

Claude: sets the tempo, loads the 909 Core Kit, writes the drum pattern, loads a sub bass and a pad from Live's browser, writes the bassline and the chords with smooth voice leading, sets the levels in dB and names everything. 17 tool calls, each one undo step in Live. See every call →

You: Turn it into a full track: intro, a build-up with a clap roll and a filter sweep, the drop, a breakdown, a second build and drop, and an outro. Add locators.

Claude: writes the variations into scenes, sweeps the pad's filter through the build, lays out all seven sections in one call and adds the locators. See every call →

Ableton Live 12.4.5 with the song from examples 1, 5 and 6, built through LiveBridge alone.

LiveBridge connects Claude (Claude Code, Claude Desktop or any MCP client) to a running Ableton Live: transport, tracks, clips, MIDI notes, audio clips and samples, built-in devices, third-party VST/AU plug-in parameters, the browser (instruments, effects, drum kits, presets, packs, user library), automation, the arrangement, scenes, locators, mixer, routing, recording and view navigation, plus Splice samples through Splice's official MCP server.

It works on macOS and Windows, with every Live 12 edition (built and verified against Live 12.4.5 Suite), with Live on the same computer as Claude or on another computer in your network, which is handy when you switch between a Mac and a Windows PC.

No Max for Live needed: the core is a small MIDI Remote Script. With Max for Live, optional LiveBridge devices add what Live's API cannot do: listening while the song plays (Engine), mixing and mastering by measurement (Channel, Master, Phase, Unmask; Channel and Master need Max 9), live modulation, follow actions, MIDI input (MIDI), faster automation recording and every parameter of a VST3 plug-in (Host) (docs/ENGINE.md). Claude adds them to your set itself when a task needs them.

What you can ask

You say	Claude does it with	Example
"Make an 8-bar house beat at 124 BPM with a 909 kit"	drum patterns by pad name, presets from Live's browser, a bassline, chords, levels in dB	1
"Write a sad progression in D minor, a bassline and an arp, and check they fit"	chords from symbols or Roman numerals, arpeggios, a music-theory check that finds clashes	2
"Load Serum 2 and design a dark Reese bass"	120 Serum 2 parameters controllable without Configure, macros, LFO automation	3
"Find a hi-hat loop on Splice and put it on a new track"	Splice's official MCP server for search and download, LiveBridge for import and warping	4
"Turn this loop into a full track with a build-up and a breakdown"	scenes, a clap roll, a filter sweep, the arrangement in one call, locators	5
"Check my mix against my reference track"	meters, a bounce, LUFS and spectrum comparison, EQ, side-chain, limiter	6
"Mix and master this track for club playback"	a channel strip per part set by role, faders balanced by role, the master driven to a loudness target, every move measured and explained	9

More in the prompt library. Scripting Live without Claude: examples/python.

Why LiveBridge

• All of Live that its API allows, not just transport and notes: 226 tools backed by 200 commands, plus direct access to the Live Object Model for anything else.
• Tools that think like a producer: drum patterns written against the kit's pad names, chords from symbols or Roman numerals with voice leading, arps and basslines from a progression, humanize/swing/groove, section layouts, filter sweeps and LFOs, mixing in dB.
• Ears: a music-theory check (key, chords, clashes between parts), audio analysis of bounces (LUFS, spectrum, stereo, tempo, key, masking between parts, before/after), technical problems (clipping, DC offset, polarity, hum, noise, resonances with an EQ bell to fix them), phase and timing between layers (kick vs sub), optionally against a reference track — and with the LiveBridge Engine, live while the song plays.
• Your whole sample library: everything Live's browser lists under Samples, searchable by words and Live's own tags, most used first, "sounds like this one", plus installed plug-ins.
• Arrangements keep their automation: scenes laid out as a song keep their clip envelopes as automation lanes, and copied sections take their lanes along (recorded in a fast background pass — Live's API drops both).
• Max for Live, optional: real-time listening, A/B and masking while playing, captures, tempo-synced modulation of any parameter, follow actions, what you played as notes, phrases played live, ~5x faster automation recording — and mixing by measurement: a sound check that finds silent or filter-strangled parts, faders set to role levels in real dB (with each band problem placed on a track or the master), and a master driven to a Spotify/Apple/club loudness target that stops before the punch collapses. "Mix and master this" is one call: live_mix_auto puts a LiveBridge Channel (a channel strip from Ableton's own DSP plus the meters, Max 9) on every track and the Engine and LiveBridge Master on the master by itself, EQs, compresses and high-passes every part for its role (with a reason for each move), fixes kick against bass, balances the faders and masters to a loudness target. Or on your own plug-ins: the master through FabFilter Pro-L 2 or the iZotope Ozone 12 Maximizer (chain="plugin"), its EQ fixes on Pro-Q 4 or the Ozone 12 Equalizer, each track's EQ and compression on Pro-Q 4 and Pro-C 3 (strip_plugins) — or just measure, balance and master around your own processing (strips="measure").
• Production know-how and memory: genre recipes, every Serum 2 control, melody craft with a checker for flat, scale-walking lines, moods turned into notes, transitions per genre, workflows, a sound library, generative rhythms and note chance, and project notes Claude remembers.
• Big plug-ins, fully controllable: Serum 2 and other VST3 synths without clicking for every knob; complete Serum 2 preset files (wavetables, mod matrix, FX order) designed, edited and loaded onto a track — your packs from older Serum builds too; and, with the LiveBridge Host device, parameter of any VST3 past Live's 128: Claude sees what you turn in the plug-in's own window, saves the patch and hands it over to a native rack with the ≤128 controls that matter.

How it works

 Claude Code / Claude Desktop / any MCP client            + Splice's official remote MCP
            │  stdio (MCP)                                  (https://mcp.splice.com/mcp)
            ▼
 ┌───────────────────────────┐   TCP JSON lines :9880    ┌──────────────────────────────────┐
 │ livebridge-mcp            │ ────────────────────────▶ │ Ableton Live 12                  │
 │ MCP server (Python ≥3.10) │ ◀──────────────────────── │  └ LiveBridge Remote Script      │
 │ 226 tools, reconnecting   │   UDP discovery :9881     │    (stdlib Python 3.11 in Live,  │
 │ client, LAN discovery     │ ◀ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ │     runs every command on Live's │
 └───────────────────────────┘                           │     main thread, 1 undo step each)│
                                                         └──────────────────────────────────┘

1. Remote Script (remote_script/LiveBridge) — loaded by Live as a control surface. It runs a small TCP server on a background thread and executes every command on Live's main thread against the Live Object Model (LOM). Every change is one undo step.
2. MCP server (mcp_server, package livebridge-mcp) — exposes curated, validated tools to Claude and talks to the Remote Script (reconnects automatically, finds Live on the LAN).
3. Installer (installers/) — copies the script into Live's User Library, writes the config with a random token, installs the MCP server, registers it (and Splice) with Claude and installs the LiveBridge skill for Claude Code and Claude Desktop.

Design and wire protocol: docs/ARCHITECTURE.md, docs/PROTOCOL.md.

Quick start

Requirements: Ableton Live 12 (any edition), Python 3.10+ for the MCP server (python.org; the installer itself runs on 3.9+ and can use uv with --uv to fetch Python for you), and Claude Desktop and/or Claude Code. Node.js is not needed: Splice goes into Claude Desktop as a connector (or, with --splice-npx, through npx mcp-remote in its config).

macOS

git clone https://github.com/morpheasgr/livebridge-ableton-mcp.git LiveBridge && cd LiveBridge
./installers/install.sh            # or: python3 installers/install.py

Windows (PowerShell)

git clone https://github.com/morpheasgr/livebridge-ableton-mcp.git LiveBridge; cd LiveBridge
powershell -ExecutionPolicy Bypass -File installers\install.ps1   # or: py installers\install.py

Without git (download)

Download the repository as a zip (GitHub: Code → Download ZIP), unzip it into a folder you keep (the MCP server runs from it) and double-click Install LiveBridge.bat (Windows) or Install LiveBridge.command (macOS; the first time right-click → Open). Later, quit Claude Desktop and double-click Update LiveBridge.bat / .command: it downloads the newest version over the folder (files you added there stay), then runs the installer again.

Then, on both

1. Start (or restart) Live.
2. Live → Preferences → Link, Tempo & MIDI → Control Surface → LiveBridge (Input/Output: None). The status bar says LiveBridge … ready on port 9880.
3. Restart Claude Desktop / open a new Claude Code session and ask: "run live_status".
4. Claude Desktop only: upload the skill the installer built — Settings → Capabilities → Skills → Upload skill → ~/.livebridge/livebridge-skill.zip (Claude Code gets it automatically).

Try: "Make a 4-bar house beat at 124 BPM with a 909 kit, a sub bass following Am–F–C–G and a pad on the chords, then loop it."

The installer is idempotent — run it again after git pull (or use the Update launcher) to update; it keeps the token and every setting you do not pass again (LAN mode, port, allow_eval, paired host). --dry-run shows every action without writing anything. Details, flags and manual setup: docs/INSTALL.md.

Two machines (Mac ↔ Windows, LAN)

Live runs on one computer, Claude on another:

# on the computer that runs Live — listen on the LAN, prints the token and this machine's IP
python installers/install.py --network

# on the computer that runs Claude
python installers/install.py --pair 192.168.1.20 --token <token printed above>

At runtime Claude can find Live instances with live_discover (UDP beacon) and switch with live_connect(host, port, token, persist=true). Firewall: the Live machine needs incoming TCP 9880; the Claude machine needs incoming UDP 9881 only for live_discover (the beacon travels from Live to Claude). On macOS 15+ allow Claude (or your terminal) and Live under Privacy & Security → Local Network — otherwise connecting fails with "No route to host". install.py --local makes a machine standalone again. See docs/NETWORK.md.

No git remote to clone from on the second computer? python installers/bundle.py packs this folder into dist/LiveBridge-<version>.zip; unzip it on the other computer into a folder you keep (the MCP server is installed from it — moving it later means re-running the installer) and run the installer there (details).

Splice

LiveBridge does not reimplement Splice: the installer registers Splice's official remote MCP (https://mcp.splice.com/mcp) next to LiveBridge (disable with --no-splice): in Claude Code directly, in Claude Desktop as a connector you add in its Settings (the checklist says how; nothing from npm runs locally — --splice-npx puts it in the config through npx mcp-remote instead). Claude searches and downloads sounds with the Splice tools (search is free; downloads need a paid plan and are limited to 100 per 24 h), then live_splice_import_downloaded(files=[<paths Splice reported>]) puts them into Live (session slot, arrangement, Simpler or a Drum Rack pad). When Live runs on another computer LiveBridge sends the files over first (into <User Library>/Samples/LiveBridge there). live_splice_watch_folder is for downloads you make by hand in the Splice app or browser; live_splice_setup_info explains the setup from inside Claude.

Serum 2 and other big plug-ins

Live exposes none of a big plug-in's parameters after loading (Serum 2 VST3/AU: 0 of 2623) — only what the device's Configure list holds, and Live's API cannot add to it. LiveBridge gets around that without a click: it writes a rack preset that lists the wanted VST3 parameters and loads the plug-in inside it.

1. live_plugin_expose(plugin="Serum 2", parameters=["sound_design"], new_track=true) — a curated set of 120 sound-design controls (oscillators, sub/noise, filters, envelopes, LFO rates, macros, FX slots); add names or groups as needed. Optional macros={"1": "Filter 1 Freq"} wires rack macros.
2. live_device_set_parameters on the returned device path with display strings ({"Filter 1 Freq": "800 Hz", "Env 1 Attack": "20 ms", "A Octave": "-1 oct", "Main Vol": "70%"}).
3. Automate them like any parameter (live_automation_write, live_automation_record).

Starting sounds: live_plugin_preset_files(plugin="Serum 2") → preset_file=. Other VST3 plug-ins: live_plugin_param_map(plugin=...) once (probes ~30 s), then expose. Limits: 128 parameters per rack, the sound restarts from the preset/template when you re-expose, .SerumPreset files cannot be embedded, Audio Units expose nothing this way (prefer VST3); the manual Configure route remains for AU / VST2. Details: docs/PLUGIN_RACKS.md.

Every parameter of any VST3 — scout in a host, play natively (needs Max for Live). Live's API only reaches the parameters in a plug-in's Configure list. The LiveBridge Host device loads a VST3 inside Max's vst~, which reaches all of them (Massive ~200, Serum 2 ~540):

1. live_plugin_host_load(plugin="Massive") — or bring a sound you saved natively in with live_plugin_host_preset(source_path=...) (a .vstpreset; a preset for another plug-in is refused by its VST3 class ID). The device's Open plug-in button opens its window.
2. Tweak in the plug-in's window; live_plugin_host_parameters(touched=true) lists what you moved, in order, with before and after values (restores such as undo are kept apart; touched="reset" starts a clean round). search= and live_plugin_host_set reach every other parameter by name and display text.
3. live_plugin_host_expose(parameters=[...≤128]) saves the hosted patch as a .vstpreset (complete state: samples, wavetables, routings), maps the plug-in once, loads it natively in a rack with those parameters exposed — automation, macros, undo as usual — and removes the host (remove_host=false keeps it and puts the native rack on its own track to compare). live_plugin_host_save alone writes the patch; live_plugin_host_bank makes hosted parameters automatable without leaving the host. Details: docs/ENGINE.md.

Production skills

Claude reads a set of guides next to the LiveBridge skill (.claude/skills/livebridge/, also served as MCP resources for Claude Desktop):

Guide	What it gives Claude
PRODUCTION.md	song structure, energy, build-ups, drops, effects, harmony, mixing targets
GENRES.md	drum patterns, bass lines, chords and sounds per genre: techno, hardgroove, house, UK and speed garage, trance, Reese/growl, synthwave, acid, ambient, hip-hop/trap/DnB
SERUM.md	Serum 2 sound design: which parameters do what, recipes (sub, 808, Reese, growl, acid, supersaw, pluck, pad, riser), what Live's API cannot change
WORKFLOWS.md	extending an arrangement, co-writing parts, starting a project, MIDI cleanup, chords, mix doctor, side-chain, reference matching, pre-master audit, vocal chain

Try: "Here's my 32-bar loop: turn it into a 6-minute track with a DJ intro and two drops", "design an acid line in Serum 2 that fits my kick", "my mix is muddy, find out why".

Tools

226 tools, named live_<area>_<verb>, backed by 200 bridge commands in the Remote Script. The full reference (every tool with its arguments and defaults, and every bridge command with the tool that runs it) is docs/TOOLS.md, generated from the code by installers/gen_tools_doc.py; Claude reads the full docstrings at runtime.

The same argument forms work in every tool: track = index, name, return letter ("A"), "master", "selected" or a LOM path; slot = scene index or name; clip = path, name or "selected"; song positions and clip lengths are beats or "17.1.1" (bars.beats.sixteenths); colours are a palette index, "#RRGGBB", [r, g, b] or a name.

Area	Examples	What you can do
Session & status	live_status, live_set_snapshot, live_connect, live_discover	Connection check, the whole set in one call, switch machines
Transport	live_transport_play/stop/set/set_loop/undo	Tempo, signature, metronome, loop, quantization, scale, undo/redo
Tracks & mixer	live_tracks_create/set/delete/duplicate, live_mixer_set/set_many/master	Create/rename/colour/arm tracks; volume/pan/sends in dB
Routing & recording	live_routing_route/set, live_record_session/arrangement/resample/capture_midi, live_mixer_meters	Resampling/bounce, buses, side-chain; record clips; capture MIDI; level meters
Clips & notes	live_clip_create/set/fire, live_clip_add_notes, live_clip_write_pattern/write_chords/write_arp, live_clip_transform_notes, live_clip_warp/convert, live_groove_pool	Step-sequenced drums, chords and arps from symbols or Roman numerals, quantize/humanize/transpose, warp markers, audio → MIDI
Arrangement & locators	live_arrangement_overview/from_scenes/duplicate_clip/resize_clip/copy_range, live_cue_layout/add, live_time_convert	Session → arrangement, song sections, bars ↔ beats
Scenes	live_scene_create/fire/set/capture	Scene tempo/signature, launch, capture
Devices & racks	live_device_insert/set_parameter/set_parameters/randomize, live_rack_macros, live_drumrack_overview, live_simpler_*	Any parameter by name/display text ("-12 dB", "1/8"), macros, drum pads, Simpler
Plug-ins	live_plugin_expose/param_map/preset_files, live_plugin_list/presets/set/parameters	Serum 2 / any VST3 fully controllable without Configure; presets and exposed parameters
Plug-in host (Max for Live)	live_plugin_host_load, live_plugin_host_parameters, live_plugin_host_set, , , ,

A Claude skill with a production workflow ships in .claude/skills/livebridge/SKILL.md. The installer copies it to ~/.claude/skills/livebridge (Claude Code, every folder) and packs ~/.livebridge/livebridge-skill.zip for Claude Desktop (Settings → Capabilities → Skills → Upload skill); --no-skill skips that. MCP clients without the skill can read the same text as the resource livebridge://skill or the prompt livebridge_workflow. The musical side — song structure, energy, build-ups, transitions, effect chains, mix targets per genre — is in PRODUCTION.md next to it (resource livebridge://production). Fewer tools in context: --toolsets core (details).

Limitations

These are limits of Live's Python API, not of LiveBridge (details and alternatives in docs/LIVE_API_NOTES.md):

• No saving the set, no audio file export, no freeze/flatten, no grouping tracks, no menu commands or preferences. A section or a track can be bounced to audio in real time (live_record_resample).
• Racks: no macro mapping, no deleting/reordering chains, no key/velocity zones, no saving presets; Sampler zones and the Drum Sampler's sample are not reachable (workarounds in LIVE_API_NOTES §12).
• Automation is drawn into session clips; arrangement automation lanes are recorded in real time (live_automation_record). Clip envelopes survive the copy to the arrangement only on tracks without an instrument (Live 12.4.5) — LiveBridge reports it.
• Third-party plug-ins expose only the parameters in their Configure list (at most 128). For VST3 plug-ins live_plugin_expose builds that list without a click (Serum 2 and Massive mapped); AU / VST2 plug-ins need the device's Configure button once. The experimental LiveBridge Host (Max for Live, VST3) reaches every parameter; hosted parameters are not Live parameters until handed over (live_plugin_host_expose) or banked, and Live's undo covers a hosted plug-in's whole state at once.
• live_device_insert (built-in devices without the browser) needs Live 12.3+; older 12.x load through the browser tools.
• Claude cannot hear audio, but can read Live's level meters and CPU load (live_mixer_meters) and works from the set's data (notes, parameters, names).
• live_eval_python runs arbitrary Python inside Live; it is on by default for the owner, always behind the token, and can be disabled with --no-allow-eval.

FAQ

Which Ableton Live versions and editions work? Live 12, in every edition. It was built against Live 12.4.5 Suite and is tested up to 12.4.16; live_device_insert needs 12.3 or later, and older 12.x versions load devices through the browser tools instead. Some example presets are Suite content; other editions use their own. Live 11 is not supported: the Remote Script is written for the Python 3.11 that Live 12 embeds.

Do I need Max for Live? No. LiveBridge is a MIDI Remote Script, the same kind of script that drives Push and other controllers, so it runs in every edition.

Which AI apps can use it? Claude Code and Claude Desktop; the installer sets both up, including the LiveBridge skill. Any other MCP client that can start a local (stdio) server works too: run livebridge-mcp (mcp_server/README.md).

Can Claude hear my music? Not directly. Claude reads what Live knows (notes, devices, parameters, levels), checks harmony with live_theory_analyze and measures bounced audio with live_audio_analyze: loudness, spectrum, stereo, tempo and key. Your ears still have the final say.

Is it free? LiveBridge is free and open source (MIT). You need Ableton Live 12 and a Claude plan; Splice is optional (searching is free, downloads use your Splice credits). If it helps your music, you can buy its original author a coffee.

Does it work on Windows? With Live and Claude on different computers? Yes to both: macOS and Windows, and Claude and Live can run on two computers in your network, Mac and PC mixed (example 7, docs/NETWORK.md).

Will it mess up my set? Every change is one undo step (Cmd/Ctrl+Z). The skill tells Claude to ask before deleting or overwriting your material and not to start playback or recording unless asked. Work on a copy of an important set anyway, and save it yourself: Live's API cannot save.

Is it safe to run? By default Live only accepts connections from the same computer, with a random token. LAN mode is opt-in, still requires the token, and is meant for your own network. Python-in-Live (live_eval_python) can be switched off with --no-allow-eval. See SECURITY.md.

How does it compare with other Ableton MCP servers? Beyond the basics (transport, tracks, clips and notes) LiveBridge covers the browser, devices and racks, third-party plug-in parameters (Serum 2 without Configure), automation in clips and the arrangement, song structure, routing and side-chains, resampling, the theory and audio analysis, Splice, two-computer setups, and direct access to the Live Object Model. Every tool is tested against a simulated Live on macOS, Windows and Linux.

Troubleshooting

Script not listed in Live, port in use, token mismatch, firewall, timeouts, plug-in parameters missing, Windows path escaping and where Log.txt lives: docs/TROUBLESHOOTING.md. python tests/integration_check.py checks a real Live end to end (and cleans up after itself); --scenario beat runs the whole beat-making chain on temporary tracks, --scenario arrangement the arrangement copy/resize/move chain.

Development

python3 -m venv .venv && .venv/bin/pip install -e "mcp_server[dev]"
.venv/bin/python -m pytest -q tests      # fake `Live` package in tests/live_stub, no Live needed

Handlers (remote_script/LiveBridge/handlers/*.py) and MCP tools (mcp_server/livebridge_mcp/tools/*.py) are auto-discovered — add a file, never edit a registry. The Remote Script is standard-library only and must stay Python 3.11 compatible. Shared argument parsing (tracks, devices, colours, times, paging) lives in remote_script/LiveBridge/resolve.py. After adding or changing a tool or command, regenerate the reference: .venv/bin/python installers/gen_tools_doc.py (tests/test_consistency.py fails when it is stale). More in CONTRIBUTING.md; changes per version in CHANGELOG.md; where the project is going in ROADMAP.md.

Support

LiveBridge is free. If it saves you time or sparks a track, you can buy its original author a coffee ☕. A star on GitHub, a bug report or a note about what you made with it helps just as much.

License

MIT — see LICENSE. LiveBridge was created by Valentijn (original repository), whose work this project is built on and whose copyright notice it keeps. It is developed further and maintained by morpheasgr: the Max for Live devices, mixing and mastering by measurement, plug-in racks and patch writing (Serum 2, Massive), sample search and more. It also builds on MIT-licensed work by others, credited with their licences in THIRD_PARTY_NOTICES.md: the Serum 2 preset codec from nicholasbien's ableton-mcp-pro (via kasperikaivola's fork), and production know-how from ableton-skills, hellyee and ableton-auto-mix-mcp, and the plug-in host's dial approach from xxnoodl's ableton_device_vst_wrapper. Ableton and Live are trademarks of Ableton AG; Splice is a trademark of Splice. LiveBridge is an independent project and not affiliated with either.