This server lets an AI agent act as a live DJ inside Ableton Live: control transport, decks, FX, and an analyzed music crate over MCP with beat-synced timing and realtime telemetry.
Session control: diagnose both Ableton connections, get full session info or cheap live status (playing, tempo, bar/beat), play/stop transport, set tempo, and save the project.
Deck control: map decks A/B to tracks, load audio files into clips, fire or stop clips with bar quantization, set deck volume, run beat-synced crossfades, and kill/restore EQ bands.
FX automation: set named PERF-rack macros, sweep or pulse FX over N bars, kill all FX on a deck, list devices, dump device parameters, and set raw plugin parameters as an escape hatch.
Crate & set planning: list analyzed tracks with BPM/key/energy, get smart next-track suggestions (BPM ±8%, Camelot-compatible, energy direction), and prepare a deck by loading a track and optionally matching tempo.
Realtime awareness: telemetry at 10 Hz gives you live transport and levels, enabling downbeat-synced actions and the human/AI collaboration layer.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@messier-live Suggest a track in 7A at 140 BPM and get it ready on deck B"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Agent-driven live sets in Ableton Live. An MCP server that gives an AI a real DJ rig: two decks over Session View, a beat clock it can actually hear, performance FX macros, and a crate that knows every track's BPM and key.
Spun out of KOTOPIA9X/kaios's
kaios_music, stripped to the live-performance core.
Claude / any MCP client
│ MCP (stdio)
messier-live server (Python)
│ TCP :9877 (commands) UDP :9878 (telemetry, 10 Hz)
▼ ▲
MessierLive Remote Script ── inside Ableton LiveTelemetry is the point: the Remote Script pushes transport, bar/beat, playing clips, and levels ten times a second, so the agent fires clips on the downbeat, crossfades in bars instead of seconds — and the same stream later feeds a website visualizer.
Related MCP server: Ableton Live MCP Ultra v2
# 1. the server
pip install -e ".[analysis]"
# 2. the remote script
cp -r remote_script/MessierLive "~/Music/Ableton/User Library/Remote Scripts/"
# Ableton > Settings > Link/MIDI > Control Surface: MessierLive
# 3. register with Claude Code
claude mcp add messier-live -- messier-live# analyze your tracks (BPM, key -> Camelot, energy) into ~/.messier-live/crate.json
python -m messier_live.crate.analyze ~/Music/dj-crateBuild the Live set template — two deck tracks with an EQ Three and a PERF
FX rack each (templates/README.md).
Layer | Tools |
session |
|
decks |
|
fx |
|
crate |
|
A set, from the agent's side:
diagnose() → deck_status()
suggest_next_track(bpm=140, camelot="7A", energy_direction="up")
prepare_deck("B", "<file>", match_tempo=False)
crossfade(to_deck="B", bars=8)
fx_pulse("A", "Glitch", bars=1) # on the way out
eq_kill("B", "low"); eq_kill("B", "low", restore=True) # drop trickSee USAGE.md for the full manual: set prep, tagging, running sets, and the human/agent collaboration contract (touch detection, 16-bar ownership, modes).
Telemetry v2 reports every shared control (macros, EQ, faders, clips) at
10 Hz. The agent journals its own writes; unexplained drift = a human hand.
Touched controls become human-owned (16 bars for FX/EQ/faders, until-stop
for clips), all agent tools yield on them, and a fired clip re-routes the
set plan through the human's choice. Modes: solo / copilot / crew.
WebSocket relay: rebroadcast telemetry + agent narration for a live website visualizer
Serum2 track: agent-composed stabs/risers between tracks
Preset hotswap (load_preset by name via browser API)
Recorded set replay logs (for the visualizer's offline mode)
Global set optimizer (current planner is greedy with lookahead-0)
List analyzed tracks in the crate (title, BPM, key, energy).
Inputs: limit. Returns: object
Beat-synced crossfade: fire the incoming deck on the next bar, then ramp
the incoming deck up and the outgoing deck down over bars bars.
Inputs: to_deck (required), bars, fire_incoming. Returns: object
Current deck mapping, what's playing on each deck, and transport state.
Inputs: no named parameters. Returns: object
Check both channels to Ableton: TCP command port and UDP telemetry.
Inputs: no named parameters. Returns: object
Kill (or restore) an EQ band on a deck. Needs an 'EQ Three' device on the deck track. band: low | mid | high.
Inputs: deck (required), band, restore. Returns: object
Fire a deck's clip. quantize='next_bar' waits for the downbeat via telemetry; 'global' fires immediately and lets Live's launch quantization align it.
Inputs: deck (required), quantize, clip_index. Returns: object
Punch a PERF macro to intensity for N bars, then cut it — glitch rolls,
echo stabs, one-bar granular washes.
Inputs: deck (required), macro (required), bars, intensity. Returns: object
Ramp a PERF macro over N bars (a filter sweep, a building glitch, a riser). direction 'up' ramps 0→1, 'down' ramps 1→0. With release=True the macro snaps back to 0 at the end (classic build-and-drop).
Inputs: deck (required), macro (required), bars, release, +1 more. Returns: object
Dump a device's parameter list (names, values, ranges) on a deck's track — for exploring a plugin (Serum2, Infiltrator, ...) before automating it.
Inputs: deck (required), device_index (required). Returns: object
Full session snapshot from Live: tracks, clips, tempo.
Inputs: no named parameters. Returns: object
Zero all PERF-rack macros on a deck (clean slate). Works with renamed macros.
Inputs: deck (required). Returns: object
List devices (and their indices) on a deck's track, so FX tools can be pointed at the right rack/plugin.
Inputs: deck (required). Returns: object
Realtime transport state from telemetry: playing, tempo, bar/beat, levels. Cheap — use this for 'where are we in the music' instead of get_session_info.
Inputs: no named parameters. Returns: object
Load an audio file into a deck's clip slot (does not start playback).
Inputs: deck (required), file_path (required), clip_index. Returns: object
Start Live's transport.
Inputs: no named parameters. Returns: object
Load a crate track onto a deck; with match_tempo=True also set Live's tempo to the track's analyzed BPM (use when starting a set, not mid-mix).
Inputs: deck (required), file_path (required), match_tempo. Returns: object
Save the current Live set.
Inputs: project_name. Returns: object
Set a deck's fader (0.0–1.0, where 0.85 is 0 dB).
Inputs: deck (required), volume (required). Returns: object
Set any raw device parameter by name on a deck's track (escape hatch when a macro doesn't cover it).
Inputs: deck (required), value (required), device_index (required), parameter_name (required). Returns: object
Set a PERF-rack macro on a deck by name (e.g. 'Glitch', 'Space', 'Crush'). value 0.0–1.0.
Inputs: deck (required), macro (required), value (required). Returns: object
Set the session tempo in BPM.
Inputs: bpm (required). Returns: object
Map decks A and B onto Session View track indices and persist the mapping.
Inputs: deck_a_track, deck_b_track. Returns: object
Stop Live's transport.
Inputs: no named parameters. Returns: object
Stop the clip playing on a deck.
Inputs: deck (required), clip_index. Returns: object
Rank crate tracks that mix well next: BPM within ±8%, Camelot-compatible key, energy 'up' | 'down' | 'hold'. Give either the current file path or bpm+camelot.
Inputs: bpm, limit, camelot, current_file, +1 more. Returns: object
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 25 tools
Tools are mostly distinct: live_status is explicitly described as the cheap telemetry option versus get_session_info, and set_fx_macro, fx_sweep, and fx_pulse are differentiated as set/ramp/punch. Minor overlap exists between load_to_deck and prepare_deck, but descriptions clarify the intended use case.
Most tools follow a predictable verb_noun snake_case pattern like set_fx_macro, fire_deck, and set_device_parameter. There are minor deviations with noun-style names like live_status, deck_status, and crate_list, plus bare verbs like play, stop, and diagnose, but the overall convention remains readable.
At 25 tools, this is on the heavy borderline for an MCP server. The broad scope—transport, deck management, FX automation, device parameter control, and crate library—largely justifies each tool, but the set feels slightly bloated and some tools could plausibly be consolidated.
The core DJ performance workflow is well covered: transport, deck load/fire/stop, volume and crossfade control, FX sweeps and pulses, device parameter escape hatches, and crate-based track suggestions. Minor gaps exist such as no open_project, no direct crossfader position control, and limited non-deck track manipulation, but these do not block the primary use case.
Score video, make music as an agent: 100+ AI instruments play your MIDI, audio, stems, Logic/Ableton
Autonomous music production for AI agents with MIDI generation, QC and provenance.
Browser DAW for AI assistants: build multitrack songs with MIDI, effects, stems and generation.
Compose, mix, master and export in Logic Pro, REAPER or Ableton Live by talking to an AI engineer.
